Switch to new Error Managers.

This is a little bit icky, but I can't see a nicer way to do it.

src/com/dmdirc/ClientModule.java

@@ -49,6 +49,10 @@ import com.dmdirc.ui.themes.ThemeManager;
 import com.dmdirc.updater.UpdaterModule;
 import com.dmdirc.util.io.Downloader;
 
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import javax.inject.Named;
 import javax.inject.Provider;
 import javax.inject.Qualifier;
 import javax.inject.Singleton;
@@ -101,6 +105,12 @@ public class ClientModule {
         return serverManager;
     }
 
+    @Provides
+    @Named("singlethread")
+    public ExecutorService getExecutorService() {
+        return Executors.newSingleThreadExecutor();
+    }
+
     @Provides
     @Singleton
     public DMDircMBassador getMBassador() {

src/com/dmdirc/config/ConfigModule.java

@@ -69,7 +69,6 @@ public class ConfigModule {
             final ErrorManager errorManager) {
         final IdentityManager identityManager = new IdentityManager(baseDirectory,
                 identitiesDirectory, eventBus, clientInfo);
-        errorManager.initialise(identityManager.getGlobalConfiguration(), errorsDirectory, eventBus);
         identityManager.loadVersionIdentity();
 
         try {
@@ -77,6 +76,7 @@ public class ConfigModule {
         } catch (InvalidIdentityFileException ex) {
             handleInvalidConfigFile(identityManager, baseDirectory);
         }
+        errorManager.initialise(identityManager.getGlobalConfiguration());
 
         if (commandLineParser.getDisableReporting()) {
             identityManager.getUserSettings().setOption("temp", "noerrorreporting", true);

src/com/dmdirc/logger/DiskLoggingErrorManager.java

@@ -23,6 +23,8 @@
 package com.dmdirc.logger;
 
 import com.dmdirc.DMDircMBassador;
+import com.dmdirc.commandline.CommandLineOptionsModule.Directory;
+import com.dmdirc.commandline.CommandLineOptionsModule.DirectoryType;
 import com.dmdirc.config.ConfigBinder;
 import com.dmdirc.config.ConfigBinding;
 import com.dmdirc.events.ErrorEvent;
@@ -39,11 +41,15 @@ import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
 
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
 import net.engio.mbassy.listener.Handler;
 
 /**
  * Listens for {@link ErrorEvent}s and writes them to disk.
  */
+@Singleton
 public class DiskLoggingErrorManager {
 
     /** The event bus to listen for errors on. */
@@ -51,31 +57,25 @@ public class DiskLoggingErrorManager {
     /** The directory to log errors to. */
     private final Path errorsDirectory;
     /** The config binder to use for settings. */
-    private final ConfigBinder configBinder;
+    private ConfigBinder configBinder;
     /** Error creating directory, don't write to disk. */
     private boolean directoryError;
     /** Are we logging errors to disk? */
     private boolean logging;
 
-    /**
-     * Creates a new instance of this error manager.
-     *
-     * @param errorsDirectory The directory to write errors to.  The error manager will try to
-     *                        create this if it is not present
-     * @param eventBus        The event bus to listen to errors on
-     * @param config          The config to read values from
-     */
-    public DiskLoggingErrorManager(final Path errorsDirectory, final DMDircMBassador eventBus,
-            final AggregateConfigProvider config) {
+    @Inject
+    public DiskLoggingErrorManager(
+            @Directory(DirectoryType.ERRORS)final Path errorsDirectory,
+            final DMDircMBassador eventBus) {
         this.errorsDirectory = errorsDirectory;
         this.eventBus = eventBus;
-        configBinder = config.getBinder();
     }
 
     /**
      * Initialises the error manager.  Must be called before logging will start.
      */
-    public void initialise() {
+    public void initialise(final AggregateConfigProvider config) {
+        configBinder = config.getBinder();
         configBinder.bind(this, DiskLoggingErrorManager.class);
         eventBus.subscribe(this);
         if (!Files.exists(errorsDirectory)) {

src/com/dmdirc/logger/ErrorManager.java

@@ -22,432 +22,59 @@
 
 package com.dmdirc.logger;
 
-import com.dmdirc.DMDircMBassador;
-import com.dmdirc.config.ConfigBinding;
-import com.dmdirc.events.AppErrorEvent;
-import com.dmdirc.events.FatalProgramErrorEvent;
-import com.dmdirc.events.NonFatalProgramErrorEvent;
-import com.dmdirc.events.ProgramErrorDeletedEvent;
-import com.dmdirc.events.UserErrorEvent;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
-import com.dmdirc.ui.FatalErrorDialog;
-import com.dmdirc.util.EventUtils;
 
-import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
-
-import java.awt.GraphicsEnvironment;
-import java.io.IOException;
-import java.nio.charset.Charset;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Date;
-import java.util.List;
 import java.util.Set;
-import java.util.concurrent.CopyOnWriteArraySet;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 
 import javax.inject.Inject;
+import javax.inject.Provider;
 import javax.inject.Singleton;
 
-import net.engio.mbassy.listener.Handler;
-import net.kencochrane.raven.DefaultRavenFactory;
-import net.kencochrane.raven.RavenFactory;
-
 /**
  * Error manager.
  */
 @Singleton
 public class ErrorManager {
 
-    /** A list of exceptions which we don't consider bugs and thus don't report. */
-    private static final Class<?>[] BANNED_EXCEPTIONS = new Class<?>[]{
-        NoSuchMethodError.class, NoClassDefFoundError.class,
-        UnsatisfiedLinkError.class, AbstractMethodError.class,
-        IllegalAccessError.class, OutOfMemoryError.class,
-        NoSuchFieldError.class,};
-    /** Error list. */
-    private final Set<ProgramError> errors;
-    /** Countdown latch to wait for FED with. */
-    private final CountDownLatch countDownLatch;
-    /** Sentry error reporter factory. */
-    private final SentryErrorReporter sentryErrorReporter;
-    /** Factory to create program errors. */
-    private final ProgramErrorFactory programErrorFactory;
-    /** Event bus to subscribe and publish errors on. */
-    private DMDircMBassador eventBus;
-    /** Whether or not to send error reports. */
-    private boolean sendReports;
-    /** Whether or not to log error reports. */
-    private boolean logReports;
-    /** Whether to submit error reports. */
-    private boolean submitReports;
-    /** Temp no error reporting. */
-    private boolean tempNoErrors;
-    /** Error creating directory, don't write to disk. */
-    private boolean directoryError;
-    /** Thread used for sending errors. */
-    private ExecutorService reportThread;
-    /** Directory to store errors in. */
-    private Path errorsDirectory;
+    private final Provider<SentryLoggingErrorManager> sentryLoggingErrorManagerProvider;
+    private final Provider<ProgramErrorManager> programErrorManagerProvider;
+    private final Provider<DiskLoggingErrorManager> diskLoggingErrorManagerProvider;
+    private SentryLoggingErrorManager sentryLoggingErrorManager;
+    private ProgramErrorManager programErrorManager;
+    private DiskLoggingErrorManager diskLoggingErrorManager;
 
-    /** Creates a new instance of ErrorListDialog. */
     @Inject
-    public ErrorManager(final SentryErrorReporter sentryErrorReporter,
-            final ProgramErrorFactory programErrorFactory) {
-        errors = new CopyOnWriteArraySet<>();
-        countDownLatch = new CountDownLatch(2);
-        this.sentryErrorReporter = sentryErrorReporter;
-        this.programErrorFactory = programErrorFactory;
-    }
-
-    /**
-     * Initialises the error manager.
-     *
-     * @param globalConfig The configuration to read settings from.
-     * @param directory    The directory to store errors in, if enabled.
-     * @param eventBus     The event bus to listen for error events on.
-     */
-    public void initialise(final AggregateConfigProvider globalConfig, final Path directory,
-            final DMDircMBassador eventBus) {
-        this.eventBus = eventBus;
-        eventBus.subscribe(this);
-        RavenFactory.registerFactory(new DefaultRavenFactory());
-        reportThread = Executors.newSingleThreadExecutor(new ThreadFactoryBuilder()
-                .setNameFormat("error-thread-%d").build());
-
-        globalConfig.getBinder().bind(this, ErrorManager.class);
-
-        errorsDirectory = directory;
-        if (!Files.exists(directory)) {
-            try {
-                Files.createDirectories(errorsDirectory);
-            } catch (IOException ex) {
-                directoryError = true;
-            }
-        }
-
-        // Loop through any existing errors and send/save them per the config.
-        for (ProgramError error : errors) {
-            if (sendReports && error.getReportStatus() == ErrorReportStatus.WAITING) {
-                sendError(error);
-            }
-
-            if (logReports) {
-                saveError(error);
-            }
-        }
+    public ErrorManager(
+            final Provider<SentryLoggingErrorManager> sentryLoggingErrorManagerProvider,
+            final Provider<ProgramErrorManager> programErrorManagerProvider,
+            final Provider<DiskLoggingErrorManager> diskLoggingErrorManagerProvider) {
+        this.sentryLoggingErrorManagerProvider = sentryLoggingErrorManagerProvider;
+        this.programErrorManagerProvider = programErrorManagerProvider;
+        this.diskLoggingErrorManagerProvider = diskLoggingErrorManagerProvider;
     }
 
-    @Handler(priority = EventUtils.PRIORITY_LOWEST)
-    public void handleAppErrorEvent(final AppErrorEvent appError) {
-        final ProgramError error = addError(appError.getLevel(), appError.getMessage(), appError
-                        .getThrowable(),
-                appError.getDetails(), true, isValidError(appError.getThrowable()));
-        if (appError.getLevel() == ErrorLevel.FATAL) {
-            eventBus.publish(new FatalProgramErrorEvent(error));
-        } else {
-            eventBus.publish(new NonFatalProgramErrorEvent(error));
-        }
+    public void initialise(final AggregateConfigProvider config) {
+        sentryLoggingErrorManager = sentryLoggingErrorManagerProvider.get();
+        diskLoggingErrorManager = diskLoggingErrorManagerProvider.get();
+        programErrorManager = programErrorManagerProvider.get();
+        sentryLoggingErrorManager.initialise(config);
+        diskLoggingErrorManager.initialise(config);
+        programErrorManager.initialise();
     }
 
-    @Handler(priority = EventUtils.PRIORITY_LOWEST)
-    public void handleUserErrorEvent(final UserErrorEvent userError) {
-        final ProgramError error = addError(userError.getLevel(), userError.getMessage(),
-                userError.getThrowable(), userError.getDetails(), false,
-                isValidError(userError.getThrowable()));
-        if (userError.getLevel() == ErrorLevel.FATAL) {
-            eventBus.publish(new FatalProgramErrorEvent(error));
-        } else {
-            eventBus.publish(new NonFatalProgramErrorEvent(error));
-        }
-    }
-
-    /**
-     * Adds a new error to the manager with the specified details.
-     *
-     * @param level     The severity of the error
-     * @param message   The error message
-     * @param throwable The exception that caused the error, if any.
-     * @param details   The details of the exception, if any.
-     * @param appError  Whether or not this is an application error
-     * @param canReport Whether or not this error can be reported
-     *
-     * @since 0.6.3m1
-     */
-    protected ProgramError addError(final ErrorLevel level, final String message,
-            final Throwable throwable, final String details, final boolean appError,
-            final boolean canReport) {
-        final ProgramError error = programErrorFactory.create(level, message, throwable,
-                getTrace(message, throwable), details, new Date(), appError);
-        return addError(error, appError, canReport);
-    }
-
-    protected ProgramError addError(
-            final ProgramError error,
-            final boolean appError,
-            final boolean canReport) {
-        addError(error);
-        if (!canReport || appError && !isValidSource(error) || !appError) {
-            error.setReportStatus(ErrorReportStatus.NOT_APPLICABLE);
-        } else if (sendReports) {
-            sendError(error);
-        }
-
-        if (logReports) {
-            saveError(error);
-        }
-        return error;
-    }
-
-
-
-    /**
-     * Determines whether or not the stack trace associated with this error is from a valid source.
-     * A valid source is one that is within a DMDirc package (com.dmdirc), and is not the DMDirc
-     * event queue.
-     *
-     * @return True if the source is valid, false otherwise
-     */
-    public boolean isValidSource(final ProgramError error) {
-        final String line = getSourceLine(error);
-
-        return line.startsWith("com.dmdirc")
-                && !line.startsWith("com.dmdirc.addons.ui_swing.DMDircEventQueue");
-    }
-
-    /**
-     * Returns the "source line" of this error, which is defined as the first line starting with a
-     * DMDirc package name (com.dmdirc). If no such line is found, returns the first line of the
-     * message.
-     *
-     * @return This error's source line
-     */
-    public String getSourceLine(final ProgramError error) {
-        for (String line : error.getTrace()) {
-            if (line.startsWith("com.dmdirc")) {
-                return line;
-            }
-        }
-
-        return error.getTrace().get(0);
-    }
-
-    /**
-     * Adds the specified error to the list of known errors and determines if it was previously
-     * added.
-     *
-     * @param error The error to be added
-     */
-    protected void addError(final ProgramError error) {
-        errors.add(error);
-    }
-
-    /**
-     * Determines whether or not the specified exception is one that we are willing to report.
-     *
-     * @param exception The exception to test
-     *
-     * @since 0.6.3m1
-     * @return True if the exception may be reported, false otherwise
-     */
-    protected boolean isValidError(final Throwable exception) {
-        Throwable target = exception;
-
-        while (target != null) {
-            for (Class<?> bad : BANNED_EXCEPTIONS) {
-                if (bad.equals(target.getClass())) {
-                    return false;
-                }
-            }
-
-            target = target.getCause();
-        }
-
-        return true;
-    }
-
-    /**
-     * Sends an error to the developers.
-     *
-     * @param error error to be sent
-     */
-    public void sendError(final ProgramError error) {
-        if (error.getReportStatus() != ErrorReportStatus.ERROR
-                && error.getReportStatus() != ErrorReportStatus.WAITING) {
-            return;
-        }
-        error.setReportStatus(ErrorReportStatus.QUEUED);
-
-        reportThread.submit(new ErrorReportingRunnable(sentryErrorReporter, error));
+    public Set<ProgramError> getErrors() {
+        return programErrorManager.getErrors();
     }
 
-    /**
-     * Called when an error needs to be deleted from the list.
-     *
-     * @param error ProgramError that changed
-     */
     public void deleteError(final ProgramError error) {
-        errors.remove(error);
-        eventBus.publish(new ProgramErrorDeletedEvent(error));
+        programErrorManager.deleteError(error);
     }
 
-    /**
-     * Deletes all errors from the manager.
-     *
-     * @since 0.6.3m1
-     */
     public void deleteAll() {
-        final Set<ProgramError> errorsCopy = Sets.newHashSet(errors);
-        errors.clear();
-        errorsCopy.forEach(e -> eventBus.publish(new ProgramErrorDeletedEvent(e)));
-    }
-
-    /**
-     * Returns the list of program errors.
-     *
-     * @return Program error list
-     */
-    public Set<ProgramError> getErrors() {
-        return Collections.unmodifiableSet(errors);
-    }
-
-    /**
-     * Fired when the program encounters an error.
-     *
-     * @param event Error that occurred
-     */
-    @Handler(priority = EventUtils.PRIORITY_LOWEST)
-    protected void fireErrorAdded(final NonFatalProgramErrorEvent event) {
-        if (!event.isHandled()) {
-            System.err.println("An error has occurred: " + event.getError().getLevel() + ": "
-                            + event.getError().getMessage());
-
-            for (String line : event.getError().getTrace()) {
-                System.err.println("\t" + line);
-            }
-        }
-    }
-
-    /**
-     * Fired when the program encounters a fatal error.
-     *
-     * @param event Error that occurred
-     */
-    @Handler(priority = EventUtils.PRIORITY_LOWEST)
-    protected void fireFatalError(final FatalProgramErrorEvent event) {
-        final boolean restart;
-        if (GraphicsEnvironment.isHeadless()) {
-            System.err.println("A fatal error has occurred: " + event.getError().getMessage());
-            for (String line : event.getError().getTrace()) {
-                System.err.println("\t" + line);
-            }
-            restart = false;
-        } else {
-            final FatalErrorDialog fed = new FatalErrorDialog(event.getError(), sentryErrorReporter,
-                    countDownLatch, sendReports);
-            fed.setVisible(true);
-            try {
-                countDownLatch.await();
-            } catch (InterruptedException ex) {
-                //Nevermind, carry on
-            }
-            restart = fed.getRestart();
-        }
-
-        if (restart) {
-            System.exit(42);
-        } else {
-            System.exit(1);
-        }
-    }
-
-    @ConfigBinding(domain = "general", key = "submitErrors")
-    public void handleSubmitErrors(final boolean value) {
-        submitReports = value;
-
-        sendReports = submitReports && !tempNoErrors;
-    }
-
-    @ConfigBinding(domain = "general", key="logerrors")
-    public void handleLogErrors(final boolean value) {
-        logReports = value;
-    }
-
-    @ConfigBinding(domain = "temp", key="noerrorreporting")
-    public void handleNoErrorReporting(final boolean value) {
-        tempNoErrors = value;
-        sendReports = submitReports && !tempNoErrors;
-    }
-
-    /**
-     * Returns this errors trace.
-     *
-     * @return Error trace
-     */
-    public List<String> getTrace(final String message, final Throwable exception) {
-        return Arrays.asList(exception == null ? message == null ? new String[0]
-                : new String[]{message} : getTrace(exception));
+        programErrorManager.deleteAll();
     }
 
-    /**
-     * Converts an exception into a string array.
-     *
-     * @param throwable Exception to convert
-     *
-     * @since 0.6.3m1
-     * @return Exception string array
-     */
-    private static String[] getTrace(final Throwable throwable) {
-        String[] trace;
-
-        if (throwable == null) {
-            trace = new String[0];
-        } else {
-            final StackTraceElement[] traceElements = throwable.getStackTrace();
-            trace = new String[traceElements.length + 1];
-
-            trace[0] = throwable.toString();
-
-            for (int i = 0; i < traceElements.length; i++) {
-                trace[i + 1] = traceElements[i].toString();
-            }
-
-            if (throwable.getCause() != null) {
-                final String[] causeTrace = getTrace(throwable.getCause());
-                final String[] newTrace = new String[trace.length + causeTrace.length];
-                trace[0] = "\nWhich caused: " + trace[0];
-
-                System.arraycopy(causeTrace, 0, newTrace, 0, causeTrace.length);
-                System.arraycopy(trace, 0, newTrace, causeTrace.length, trace.length);
-
-                trace = newTrace;
-            }
-        }
-
-        return trace;
-    }
-
-    private void saveError(final ProgramError error) {
-        if (directoryError) {
-            return;
-        }
-        final String logName = error.getDate().getTime() + "-" + error.getLevel();
-        final Path errorFile = errorsDirectory.resolve(logName + ".log");
-        final List<String> data = Lists.newArrayList("Date: " + error.getDate(),
-                "Level: " + error.getLevel(),
-                "Description: " + error.getMessage(),
-                "Details: ");
-        error.getTrace().forEach(line -> data.add('\t' + line));
-        try {
-            Files.write(errorFile, data, Charset.forName("UTF-8"));
-        } catch (IOException ex) {
-            //Not really anything we can do at this point, so don't try.
-        }
+    public void sendError(final ProgramError error) {
+        sentryLoggingErrorManager.sendError(error);
     }
 }

src/com/dmdirc/logger/ProgramErrorManager.java

@@ -30,12 +30,15 @@ import com.dmdirc.events.ProgramErrorEvent;
 import com.google.common.base.Throwables;
 
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;
 import java.util.HashSet;
-import java.util.List;
 import java.util.Set;
-import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.CopyOnWriteArraySet;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
 
 import net.engio.mbassy.listener.Handler;
 
@@ -43,25 +46,22 @@ import net.engio.mbassy.listener.Handler;
  * Listens for {@link ErrorEvent}s, creates {@link ProgramError}s and raises {@link
  * ProgramErrorEvent}s.
  */
+@Singleton
 public class ProgramErrorManager {
 
     /** The event bus to listen for errors on. */
     private final DMDircMBassador eventBus;
     /** The current list of errors. */
-    private final List<ProgramError> errors;
+    private final Set<ProgramError> errors;
     /** Factory to create {@link ProgramError}s. */
     private final ProgramErrorFactory programErrorFactory;
 
-    /**
-     * Creates a new instance of this error manager.
-     *
-     * @param eventBus        The event bus to listen to errors on
-     */
+    @Inject
     public ProgramErrorManager(final DMDircMBassador eventBus,
             final ProgramErrorFactory programErrorFactory) {
         this.eventBus = eventBus;
         this.programErrorFactory = programErrorFactory;
-        errors = new CopyOnWriteArrayList<>();
+        errors = new CopyOnWriteArraySet<>();
     }
 
     /**
@@ -123,7 +123,7 @@ public class ProgramErrorManager {
      * @since 0.6.3m1
      */
     public void deleteAll() {
-        final Set<ProgramError> errorsCopy = new HashSet<>(errors);
+        final Collection<ProgramError> errorsCopy = new HashSet<>(errors);
         errors.clear();
         errorsCopy.stream().map(ProgramErrorDeletedEvent::new).forEach(eventBus::publish);
     }
@@ -133,7 +133,7 @@ public class ProgramErrorManager {
      *
      * @return Program error list
      */
-    public List<ProgramError> getErrors() {
-        return Collections.unmodifiableList(errors);
+    public Set<ProgramError> getErrors() {
+        return Collections.unmodifiableSet(errors);
     }
 }

src/com/dmdirc/logger/SentryLoggingErrorManager.java

@@ -26,17 +26,23 @@ import com.dmdirc.DMDircMBassador;
 import com.dmdirc.config.ConfigBinder;
 import com.dmdirc.config.ConfigBinding;
 import com.dmdirc.events.ProgramErrorEvent;
+import com.dmdirc.events.ProgramErrorStatusEvent;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 
 import java.util.Collection;
 import java.util.Optional;
 import java.util.concurrent.ExecutorService;
 
+import javax.inject.Inject;
+import javax.inject.Named;
+import javax.inject.Singleton;
+
 import net.engio.mbassy.listener.Handler;
 
 /**
  * Listens for {@link ProgramErrorEvent}s and reports these to Sentry.
  */
+@Singleton
 public class SentryLoggingErrorManager {
 
     /** A list of exceptions which we don't consider bugs and thus don't report. */
@@ -47,8 +53,6 @@ public class SentryLoggingErrorManager {
             NoSuchFieldError.class,};
     /** The event bus to listen for errors on. */
     private final DMDircMBassador eventBus;
-    /** The config binder to use for settings. */
-    private final ConfigBinder configBinder;
     /** Sentry error reporter factory. */
     private final SentryErrorReporter sentryErrorReporter;
     /** Thread used for sending errors. */
@@ -60,25 +64,20 @@ public class SentryLoggingErrorManager {
     /** Whether or not to send error reports. */
     private boolean sendReports;
 
-    /**
-     * Creates a new instance of this error manager.
-     *
-     * @param eventBus        The event bus to listen to errors on
-     * @param config          The config to read values from
-     */
+    @Inject
     public SentryLoggingErrorManager(final DMDircMBassador eventBus,
-            final AggregateConfigProvider config, final SentryErrorReporter sentryErrorReporter,
-            final ExecutorService executorService) {
+            final SentryErrorReporter sentryErrorReporter,
+            @Named("singlethread") final ExecutorService executorService) {
         this.eventBus = eventBus;
         this.sentryErrorReporter = sentryErrorReporter;
         this.executorService = executorService;
-        configBinder = config.getBinder();
     }
 
     /**
      * Initialises the error manager.  Must be called before logging will start.
      */
-    public void initialise() {
+    public void initialise(final AggregateConfigProvider config) {
+        final ConfigBinder configBinder = config.getBinder();
         configBinder.bind(this, SentryLoggingErrorManager.class);
         eventBus.subscribe(this);
     }
@@ -90,11 +89,16 @@ public class SentryLoggingErrorManager {
                 || !isValidSource(error.getError().getTrace())
                 || !appError) {
             error.getError().setReportStatus(ErrorReportStatus.NOT_APPLICABLE);
+            eventBus.publish(new ProgramErrorStatusEvent(error.getError()));
         } else if (sendReports) {
-            executorService.submit(new ErrorReportingRunnable(sentryErrorReporter, error.getError()));
+            sendError(error.getError());
         }
     }
 
+    void sendError(final ProgramError error) {
+        executorService.submit(new ErrorReportingRunnable(sentryErrorReporter, error));
+    }
+
     @ConfigBinding(domain = "general", key = "submitErrors")
     void handleSubmitErrors(final boolean value) {
         submitReports = value;

test/com/dmdirc/logger/DiskLoggingErrorManagerTest.java

@@ -59,13 +59,13 @@ public class DiskLoggingErrorManagerTest {
     public void setUp() throws Exception {
         when(config.getBinder()).thenReturn(configBinder);
         fileSystem = Jimfs.newFileSystem(Configuration.unix());
-        instance = new DiskLoggingErrorManager(fileSystem.getPath("/errors"), eventBus, config);
+        instance = new DiskLoggingErrorManager(fileSystem.getPath("/errors"), eventBus);
     }
 
     @Test
     public void testInitialise() throws Exception {
         assertFalse(Files.exists(fileSystem.getPath("/errors")));
-        instance.initialise();
+        instance.initialise(config);
         verify(configBinder).bind(instance, DiskLoggingErrorManager.class);
         assertTrue(Files.exists(fileSystem.getPath("/errors")));
         assertFalse(instance.isDirectoryError());
@@ -80,7 +80,7 @@ public class DiskLoggingErrorManagerTest {
     public void testHandleErrorEvent() throws Exception {
         final UserErrorEvent error = new UserErrorEvent(ErrorLevel.MEDIUM,
                 new IllegalStateException(""), "", "");
-        instance.initialise();
+        instance.initialise(config);
         instance.handleLoggingSetting(true);
         final String logName = error.getTimestamp() + "-" + error.getLevel() + ".log";;
         assertFalse(Files.exists(fileSystem.getPath("/errors", logName)));
@@ -95,7 +95,7 @@ public class DiskLoggingErrorManagerTest {
         final UserErrorEvent error = new UserErrorEvent(ErrorLevel.MEDIUM,
                 new IllegalStateException(""),
                 "", "");
-        instance.initialise();
+        instance.initialise(config);
         instance.handleLoggingSetting(false);
         final String logName = error.getTimestamp() + "-" + error.getLevel() + ".log";;
         assertFalse(Files.exists(fileSystem.getPath("/errors", logName)));

test/com/dmdirc/logger/SentryLoggingErrorManagerTest.java

@@ -67,9 +67,9 @@ public class SentryLoggingErrorManagerTest {
         when(userErrorEvent.getError()).thenReturn(userError);
         when(userError.isAppError()).thenReturn(false);
         when(config.getBinder()).thenReturn(configBinder);
-        instance = new SentryLoggingErrorManager(eventBus, config, sentryErrorReporter,
+        instance = new SentryLoggingErrorManager(eventBus, sentryErrorReporter,
                 MoreExecutors.newDirectExecutorService());
-        instance.initialise();
+        instance.initialise(config);
         instance.handleSubmitErrors(true);
         instance.handleNoErrorReporting(false);
     }