Tidy up a little in logger.

src/com/dmdirc/config/ConfigModule.java

             final ErrorManager errorManager) {
         final IdentityManager identityManager = new IdentityManager(baseDirectory,
                 identitiesDirectory, eventBus, clientInfo);
-        errorManager.initialise(identityManager.getGlobalConfiguration(), errorsDirectory,
-                eventBus, clientInfo);
+        errorManager.initialise(identityManager.getGlobalConfiguration(), errorsDirectory, eventBus);
         identityManager.loadVersionIdentity();
 
         try {

src/com/dmdirc/logger/ErrorManager.java

 import com.dmdirc.events.UserErrorEvent;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.ui.FatalErrorDialog;
-import com.dmdirc.util.ClientInfo;
 import com.dmdirc.util.EventUtils;
 import com.dmdirc.util.collections.ListenerList;
 
     private final ListenerList errorListeners = new ListenerList();
     /** Countdown latch to wait for FED with. */
     private final CountDownLatch countDownLatch;
+    /** Sentry error reporter factory. */
+    private final SentryErrorReporter sentryErrorReporter;
     /** Event bus to subscribe and publish errors on. */
     private DMDircMBassador eventBus;
     /** Whether or not to send error reports. */
     private ExecutorService reportThread;
     /** Directory to store errors in. */
     private Path errorsDirectory;
-    private ClientInfo clientInfo;
 
     /** Creates a new instance of ErrorListDialog. */
     @Inject
-    public ErrorManager() {
+    public ErrorManager(final SentryErrorReporter sentryErrorReporter) {
         errors = new LinkedList<>();
         countDownLatch = new CountDownLatch(2);
+        this.sentryErrorReporter = sentryErrorReporter;
     }
 
     /**
      * @param eventBus     The event bus to listen for error events on.
      */
     public void initialise(final AggregateConfigProvider globalConfig, final Path directory,
-            final DMDircMBassador eventBus, final ClientInfo clientInfo) {
-        this.clientInfo = clientInfo;
+            final DMDircMBassador eventBus) {
         this.eventBus = eventBus;
         eventBus.subscribe(this);
         RavenFactory.registerFactory(new DefaultRavenFactory());
         }
         error.setReportStatus(ErrorReportStatus.QUEUED);
 
-        reportThread.submit(new ErrorReportingRunnable(error, clientInfo));
+        reportThread.submit(new ErrorReportingRunnable(sentryErrorReporter, error));
     }
 
     /**

src/com/dmdirc/logger/ErrorReportingRunnable.java

 
 package com.dmdirc.logger;
 
-import com.dmdirc.util.ClientInfo;
-
 /**
  * Runnable that reports an error.
  */
 public class ErrorReportingRunnable implements Runnable {
 
     private final ProgramError error;
-    private final ClientInfo clientInfo;
+    private final SentryErrorReporter sentryErrorReporter;
 
     /**
      * Runnable used to report errors.
      *
      * @param error Error to report
      */
-    public ErrorReportingRunnable(final ProgramError error, final ClientInfo clientInfo) {
+    public ErrorReportingRunnable(final SentryErrorReporter sentryErrorReporter,
+            final ProgramError error) {
         this.error = error;
-        this.clientInfo = clientInfo;
+        this.sentryErrorReporter = sentryErrorReporter;
     }
 
     @Override
     public void run() {
-        do {
-            error.setReportStatus(ErrorReportStatus.SENDING);
-            new ErrorReporter(clientInfo).sendException(error.getMessage(), error.getLevel(), error
-                    .getDate(), error.getThrowable(), error.getDetails());
-            error.setReportStatus(ErrorReportStatus.FINISHED);
-        } while (error.getReportStatus() == ErrorReportStatus.QUEUED);
+        error.setReportStatus(ErrorReportStatus.SENDING);
+        sentryErrorReporter.sendException(error.getMessage(), error.getLevel(), error.getDate(),
+                error.getThrowable(), error.getDetails());
+        error.setReportStatus(ErrorReportStatus.FINISHED);
     }
 
 }

src/com/dmdirc/logger/ProgramError.java

 /**
  * Stores a program error.
  */
-public final class ProgramError implements Serializable {
+public class ProgramError implements Serializable {
 
     /** A version number for this class. */
     private static final long serialVersionUID = 4;

src/com/dmdirc/logger/ErrorReporter.java → src/com/dmdirc/logger/SentryErrorReporter.java

 import java.util.Date;
 
 import javax.annotation.Nullable;
+import javax.inject.Inject;
+import javax.inject.Singleton;
 
 import net.kencochrane.raven.Raven;
 import net.kencochrane.raven.RavenFactory;
 /**
  * Facilitates reporting errors to the DMDirc developers.
  */
-public class ErrorReporter {
+@Singleton
+public class SentryErrorReporter {
 
     /** DSN used to connect to Sentry. */
     private static final String SENTRY_DSN = "https://d53a31a3c53c4a4f91c5ff503e612677:"
     private static final String MODE_ALIAS_TEMPLATE = "%s\n\nConnection headers:\n%s";
     private final ClientInfo clientInfo;
 
-    public ErrorReporter(final ClientInfo clientInfo) {
+    @Inject
+    public SentryErrorReporter(final ClientInfo clientInfo) {
         this.clientInfo = clientInfo;
     }
 

test/com/dmdirc/logger/ErrorReportStatusTest.java

 
     @Test
     public void testTerminal() {
-        assertTrue(ErrorReportStatus.ERROR.isTerminal());
         assertTrue(ErrorReportStatus.WAITING.isTerminal());
+        assertTrue(ErrorReportStatus.ERROR.isTerminal());
+        assertFalse(ErrorReportStatus.QUEUED.isTerminal());
         assertFalse(ErrorReportStatus.SENDING.isTerminal());
         assertTrue(ErrorReportStatus.FINISHED.isTerminal());
         assertTrue(ErrorReportStatus.NOT_APPLICABLE.isTerminal());

test/com/dmdirc/logger/ProgramErrorTest.java

 package com.dmdirc.logger;
 
 import com.dmdirc.DMDircMBassador;
+import com.dmdirc.events.ProgramErrorStatusEvent;
 import com.dmdirc.util.ClientInfo;
 
 import com.google.common.collect.Lists;
 
 import java.util.Date;
+import java.util.List;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
 
 @RunWith(MockitoJUnitRunner.class)
 public class ProgramErrorTest {
     @Mock private ErrorManager errorManager;
     @Mock private DMDircMBassador eventBus;
     @Mock private ClientInfo clientInfo;
+    @Captor private ArgumentCaptor<ProgramErrorStatusEvent> event;
 
     @Test(expected = NullPointerException.class)
     public void testConstructorNullErrorLevel() {
         assertEquals(ErrorReportStatus.WAITING, pe.getReportStatus());
         pe.setReportStatus(null);
         assertEquals(ErrorReportStatus.WAITING, pe.getReportStatus());
+        verify(eventBus, never()).publishAsync(event.capture());
         pe.setReportStatus(ErrorReportStatus.WAITING);
         assertEquals(ErrorReportStatus.WAITING, pe.getReportStatus());
+        verify(eventBus, never()).publishAsync(event.capture());
         pe.setReportStatus(ErrorReportStatus.ERROR);
         assertEquals(ErrorReportStatus.ERROR, pe.getReportStatus());
+        verify(eventBus).publishAsync(event.capture());
+        assertEquals(pe, event.getValue().getError());
     }
 
     @Test
         assertTrue(pe.toString().contains("moo"));
     }
 
+    @Test
+    public void testGetTrace() {
+        final List<String> trace = Lists.newArrayList("test", "test1", "test2");
+        final ProgramError pe = new ProgramError(ErrorLevel.HIGH, "moo",
+                new UnsupportedOperationException(), trace, null, new Date(), errorManager,
+                eventBus);
+        assertEquals(trace, pe.getTrace());
+    }
+
     @Test
     public void testEquals() {
         final Exception ex = new UnsupportedOperationException();

test/com/dmdirc/logger/ErrorReporterTest.java → test/com/dmdirc/logger/SentryErrorReporterTest.java

 import static org.mockito.Mockito.when;
 
 @RunWith(MockitoJUnitRunner.class)
-public class ErrorReporterTest {
+public class SentryErrorReporterTest {
 
     private static RavenFactory ravenFactory;
     @Mock private Raven raven;
     @Mock private ClientInfo clientInfo;
     @Captor private ArgumentCaptor<Event> eventCaptor;
-    private ErrorReporter errorReporter;
+    private SentryErrorReporter sentryErrorReporter;
 
     @BeforeClass
     public static void setUpClass() {
     @Before
     public void setUp() {
         when(ravenFactory.createRavenInstance(Matchers.<Dsn>anyObject())).thenReturn(raven);
-        errorReporter = new ErrorReporter(clientInfo);
+        sentryErrorReporter = new SentryErrorReporter(clientInfo);
     }
 
     @Test
     public void testSendsMessage() {
-        errorReporter.sendException("message 123", ErrorLevel.MEDIUM, new Date(), null, null);
+        sentryErrorReporter.sendException("message 123", ErrorLevel.MEDIUM, new Date(), null, null);
         verify(raven).sendEvent(eventCaptor.capture());
         assertEquals("message 123", eventCaptor.getValue().getMessage());
     }
     @Test
     public void testSendsTimestamp() {
         final Date date = new Date(561859200000l);
-        errorReporter.sendException("message 123", ErrorLevel.MEDIUM, date, null, null);
+        sentryErrorReporter.sendException("message 123", ErrorLevel.MEDIUM, date, null, null);
         verify(raven).sendEvent(eventCaptor.capture());
         assertEquals(date, eventCaptor.getValue().getTimestamp());
     }
 
     @Test
     public void testSendsLowLevelAsInfo() {
-        errorReporter.sendException("message 123", ErrorLevel.LOW, new Date(), null, null);
+        sentryErrorReporter.sendException("message 123", ErrorLevel.LOW, new Date(), null, null);
         verify(raven).sendEvent(eventCaptor.capture());
         assertEquals(Event.Level.INFO, eventCaptor.getValue().getLevel());
     }
 
     @Test
     public void testSendsMediumLevelAsWarning() {
-        errorReporter.sendException("message 123", ErrorLevel.MEDIUM, new Date(), null, null);
+        sentryErrorReporter.sendException("message 123", ErrorLevel.MEDIUM, new Date(), null, null);
         verify(raven).sendEvent(eventCaptor.capture());
         assertEquals(Event.Level.WARNING, eventCaptor.getValue().getLevel());
     }
 
     @Test
     public void testSendsHighLevelAsError() {
-        errorReporter.sendException("message 123", ErrorLevel.HIGH, new Date(), null, null);
+        sentryErrorReporter.sendException("message 123", ErrorLevel.HIGH, new Date(), null, null);
         verify(raven).sendEvent(eventCaptor.capture());
         assertEquals(Event.Level.ERROR, eventCaptor.getValue().getLevel());
     }
 
     @Test
     public void testSendsFatalLevelAsFatal() {
-        errorReporter.sendException("message 123", ErrorLevel.FATAL, new Date(), null, null);
+        sentryErrorReporter.sendException("message 123", ErrorLevel.FATAL, new Date(), null, null);
         verify(raven).sendEvent(eventCaptor.capture());
         assertEquals(Event.Level.FATAL, eventCaptor.getValue().getLevel());
     }
 
     @Test
     public void testSendsUnknownLevelAsInfo() {
-        errorReporter.sendException("message 123", ErrorLevel.UNKNOWN, new Date(), null, null);
+        sentryErrorReporter.sendException("message 123", ErrorLevel.UNKNOWN, new Date(), null, null);
         verify(raven).sendEvent(eventCaptor.capture());
         assertEquals(Event.Level.INFO, eventCaptor.getValue().getLevel());
     }
 
     @Test
     public void testAddsDetailsAsExtra() {
-        errorReporter.sendException("message 123", ErrorLevel.UNKNOWN, new Date(), null,
+        sentryErrorReporter.sendException("message 123", ErrorLevel.UNKNOWN, new Date(), null,
                 "details 456");
         verify(raven).sendEvent(eventCaptor.capture());
         assertEquals("details 456", eventCaptor.getValue().getExtra().get("details"));
     @Test
     public void testAddsExceptionInterface() {
         final Exception exception = new IndexOutOfBoundsException("Message blah");
-        errorReporter.sendException("message 123", ErrorLevel.UNKNOWN, new Date(), exception, null);
+        sentryErrorReporter.sendException("message 123", ErrorLevel.UNKNOWN, new Date(), exception, null);
         verify(raven).sendEvent(eventCaptor.capture());
         final SentryInterface iface = eventCaptor.getValue().getSentryInterfaces()
                 .get(ExceptionInterface.EXCEPTION_INTERFACE);