Merge pull request #593 from greboid/dev2

Remove error events and tidy up error management.

src/com/dmdirc/Main.java

@@ -37,6 +37,7 @@ import com.dmdirc.interfaces.ui.UIController;
 import com.dmdirc.logger.DMDircExceptionHandler;
 import com.dmdirc.logger.ModeAliasReporter;
 import com.dmdirc.logger.ProgramErrorAppender;
+import com.dmdirc.logger.ProgramErrorManager;
 import com.dmdirc.plugins.CorePluginExtractor;
 import com.dmdirc.plugins.PluginManager;
 import com.dmdirc.plugins.Service;
@@ -98,6 +99,7 @@ public class Main {
     /** Mode alias reporter to use. */
     private final ModeAliasReporter reporter;
     private final ServiceManager serviceManager;
+    private final ProgramErrorManager errorManager;
 
     static {
         // TODO: Can this go in a Dagger module?
@@ -107,6 +109,7 @@ public class Main {
         context.reset();
     }
 
+
     /**
      * Creates a new instance of {@link Main}.
      */
@@ -124,7 +127,8 @@ public class Main {
             final DMDircMBassador eventBus,
             final Set<CommandDetails> commands,
             final ModeAliasReporter reporter,
-            final ServiceManager serviceManager) {
+            final ServiceManager serviceManager,
+            final ProgramErrorManager errorManager) {
         this.identityManager = identityManager;
         this.connectionManager = connectionManager;
         this.commandLineParser = commandLineParser;
@@ -138,6 +142,7 @@ public class Main {
         this.commands = commands;
         this.reporter = reporter;
         this.serviceManager = serviceManager;
+        this.errorManager = errorManager;
     }
 
     /**
@@ -278,7 +283,7 @@ public class Main {
         // TODO: Add a normal logging thing, with or without runtime switching.
         final LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
         final ProgramErrorAppender appender = new ProgramErrorAppender();
-        appender.setEventBus(eventBus);
+        appender.setProgramErrorManager(errorManager);
         appender.setContext(context);
         appender.setName("Error Logger");
         appender.start();

src/com/dmdirc/events/AppErrorEvent.java

@@ -1,37 +0,0 @@
-/*
- * Copyright (c) 2006-2015 DMDirc Developers
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package com.dmdirc.events;
-
-import com.dmdirc.logger.ErrorLevel;
-
-/**
- * Event class for app errors.
- */
-public class AppErrorEvent extends ErrorEvent {
-
-    public AppErrorEvent(final ErrorLevel level, final Throwable throwable, final String message,
-            final String details) {
-        super(level, throwable, message, details);
-    }
-
-}

src/com/dmdirc/events/UserErrorEvent.java

@@ -1,37 +0,0 @@
-/*
- * Copyright (c) 2006-2015 DMDirc Developers
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package com.dmdirc.events;
-
-import com.dmdirc.logger.ErrorLevel;
-
-/**
- * Event class for user errors.
- */
-public class UserErrorEvent extends ErrorEvent {
-
-    public UserErrorEvent(final ErrorLevel level, final Throwable throwable, final String message,
-            final String details) {
-        super(level, throwable, message, details);
-    }
-
-}

src/com/dmdirc/logger/DiskLoggingErrorManager.java

@@ -28,9 +28,9 @@ import com.dmdirc.commandline.CommandLineOptionsModule.DirectoryType;
 import com.dmdirc.config.ConfigBinder;
 import com.dmdirc.config.ConfigBinding;
 import com.dmdirc.events.ErrorEvent;
+import com.dmdirc.events.ProgramErrorEvent;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 
-import com.google.common.base.Throwables;
 import com.google.common.collect.Lists;
 
 import java.io.IOException;
@@ -96,19 +96,19 @@ public class DiskLoggingErrorManager {
     }
 
     @Handler
-    void handleErrorEvent(final ErrorEvent error) {
+    void handleErrorEvent(final ProgramErrorEvent error) {
         if (directoryError || !logging) {
             return;
         }
-        final String logName = error.getTimestamp() + "-" + error.getLevel();
+        final String logName = error.getTimestamp() + "-" + error.getError().getLevel();
         final Path errorFile = errorsDirectory.resolve(logName + ".log");
         final List<String> data = Lists
                 .newArrayList("Date: " + new Date(error.getTimestamp()),
-                        "Level: " + error.getLevel(),
-                        "Description: " + error.getMessage(),
+                        "Level: " + error.getError().getLevel(),
+                        "Description: " + error.getError().getMessage(),
                         "Details: ");
-        Arrays.stream(Throwables.getStackTraceAsString(error.getThrowable()).split("\n"))
-                .forEach(data::add);
+        error.getError().getThrowableAsString()
+                .ifPresent(s -> Arrays.stream(s.split("\n")).forEach(data::add));
         try {
             Files.write(errorFile, data, Charset.forName("UTF-8"));
         } catch (IOException ex) {

src/com/dmdirc/logger/ErrorReportingRunnable.java

@@ -45,7 +45,7 @@ public class ErrorReportingRunnable implements Runnable {
     public void run() {
         error.setReportStatus(ErrorReportStatus.SENDING);
         sentryErrorReporter.sendException(error.getMessage(), error.getLevel(), error.getDate(),
-                error.getThrowable(), error.getDetails());
+                error.getThrowable());
         error.setReportStatus(ErrorReportStatus.FINISHED);
     }
 

src/com/dmdirc/logger/ProgramError.java

@@ -26,14 +26,14 @@ import com.dmdirc.DMDircMBassador;
 import com.dmdirc.events.ProgramErrorStatusEvent;
 
 import com.google.common.base.MoreObjects;
-import com.google.common.collect.Lists;
+import com.google.common.base.Throwables;
 
 import java.io.Serializable;
-import java.util.Collections;
 import java.util.Date;
-import java.util.List;
 import java.util.Objects;
+import java.util.Optional;
 
+import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 import static com.google.common.base.Preconditions.checkNotNull;
@@ -50,15 +50,11 @@ public class ProgramError implements Serializable {
     /** Error message. */
     private final String message;
     /** Underlying exception. */
-    private final Throwable exception;
-    /** The trace for this exception. */
-    private final List<String> trace;
-    /** Underlying details message. */
-    private final String details;
+    private final Optional<Throwable> exception;
     /** Date/time error first occurred. */
-    private final Date firstDate;
+    private final Date date;
     /** The eventbus to post status changes to. */
-    private final DMDircMBassador eventBus;
+    private final Optional<DMDircMBassador> eventBus;
     /** Is this an application error? */
     private final boolean appError;
     /** Error report Status. */
@@ -72,29 +68,27 @@ public class ProgramError implements Serializable {
      * @param level     Error level
      * @param message   Error message
      * @param exception The exception that caused the error, if any.
-     * @param trace     The textual trace for this error
-     * @param details   The detailed cause of the error, if any.
      * @param date      Error time and date
      * @param eventBus  The event bus to post status changes to
      */
-    public ProgramError(final ErrorLevel level, final String message,
+    public ProgramError(
+            @Nonnull final ErrorLevel level,
+            @Nonnull final String message,
             @Nullable final Throwable exception,
-            final Iterable<String> trace,
-            @Nullable final String details,
-            final Date date,
-            final DMDircMBassador eventBus,
+            @Nonnull final Date date,
+            @Nullable final DMDircMBassador eventBus,
             final boolean appError) {
         checkNotNull(level);
+        checkNotNull(message);
+        checkNotNull(level);
         checkNotNull(date);
 
         this.level = level;
         this.message = message;
-        this.exception = exception;
-        this.trace = Lists.newArrayList(trace);
-        this.details = details;
-        this.firstDate = (Date) date.clone();
+        this.exception = Optional.ofNullable(exception);
+        this.date = (Date) date.clone();
         this.reportStatus = ErrorReportStatus.WAITING;
-        this.eventBus = eventBus;
+        this.eventBus = Optional.ofNullable(eventBus);
         this.appError = appError;
     }
 
@@ -116,21 +110,12 @@ public class ProgramError implements Serializable {
         return message;
     }
 
-    public String getDetails() {
-        return details;
-    }
-
-    public Throwable getThrowable() {
+    public Optional<Throwable> getThrowable() {
         return exception;
     }
 
-    /**
-     * Returns this errors trace.
-     *
-     * @return Error trace
-     */
-    public List<String> getTrace() {
-        return Collections.unmodifiableList(trace);
+    public Optional<String> getThrowableAsString() {
+        return exception.map(Throwables::getStackTraceAsString);
     }
 
     /**
@@ -139,7 +124,7 @@ public class ProgramError implements Serializable {
      * @return Error time
      */
     public Date getDate() {
-        return (Date) firstDate.clone();
+        return (Date) date.clone();
     }
 
     /**
@@ -159,7 +144,7 @@ public class ProgramError implements Serializable {
     public void setReportStatus(final ErrorReportStatus newStatus) {
         if (newStatus != null && reportStatus != newStatus) {
             reportStatus = newStatus;
-            eventBus.publishAsync(new ProgramErrorStatusEvent(this));
+            eventBus.ifPresent(e -> e.publishAsync(new ProgramErrorStatusEvent(this)));
         }
     }
 
@@ -199,24 +184,18 @@ public class ProgramError implements Serializable {
 
     @Override
     public boolean equals(final Object obj) {
-        if (obj == null) {
-            return false;
-        }
-
-        if (getClass() != obj.getClass()) {
-            return false;
+        if (obj instanceof ProgramError) {
+            final ProgramError other = (ProgramError) obj;
+            return Objects.equals(getLevel(), other.getLevel()) &&
+                    Objects.equals(getMessage(), other.getMessage()) &&
+                    Objects.equals(getThrowable(), other.getThrowable());
         }
-
-        final ProgramError other = (ProgramError) obj;
-        return Objects.equals(getLevel(), other.getLevel())
-                && Objects.equals(getMessage(), other.getMessage())
-                && Objects.equals(getThrowable(), other.getThrowable())
-                && Objects.equals(getDetails(), other.getDetails());
+        return false;
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(level, message, exception, details);
+        return Objects.hash(level, message, exception);
     }
 
 }

src/com/dmdirc/logger/ProgramErrorAppender.java

@@ -22,33 +22,20 @@
 
 package com.dmdirc.logger;
 
-import com.dmdirc.DMDircMBassador;
-import com.dmdirc.events.AppErrorEvent;
-import com.dmdirc.events.UserErrorEvent;
-import com.dmdirc.logger.ErrorLevel;
-import com.dmdirc.logger.ProgramError;
-
 import ch.qos.logback.classic.spi.ILoggingEvent;
 import ch.qos.logback.core.AppenderBase;
 
-import static com.dmdirc.util.LogUtils.APP_ERROR;
-import static com.dmdirc.util.LogUtils.FATAL_APP_ERROR;
-import static com.dmdirc.util.LogUtils.FATAL_USER_ERROR;
-import static com.dmdirc.util.LogUtils.USER_ERROR;
-import static com.dmdirc.util.LogUtils.getErrorLevel;
-import static com.dmdirc.util.LogUtils.getThrowable;
-
 /**
  * Converts log states into {@link ProgramError}s so they can be displayed to the user.
  */
 public class ProgramErrorAppender extends AppenderBase<ILoggingEvent> {
 
-    private DMDircMBassador eventBus;
+    private ProgramErrorManager errorManager;
 
     @Override
     public void start() {
-        if (eventBus == null) {
-            addError("No eventBus set for the appender named ["+ name +"].");
+        if (errorManager == null) {
+            addError("No error manager set for the appender named ["+ name +"].");
             return;
         }
         super.start();
@@ -59,23 +46,10 @@ public class ProgramErrorAppender extends AppenderBase<ILoggingEvent> {
         if (eventObject.getMarker() == null) {
             return;
         }
-        if (eventObject.getMarker() == APP_ERROR) {
-            eventBus.publish(new AppErrorEvent(
-                    getErrorLevel(eventObject.getLevel()),
-                    getThrowable(eventObject), eventObject.getFormattedMessage(), ""));
-        } else if (eventObject.getMarker() == USER_ERROR) {
-            eventBus.publish(new UserErrorEvent(getErrorLevel(eventObject.getLevel()),
-                    getThrowable(eventObject), eventObject.getFormattedMessage(), ""));
-        } else if (eventObject.getMarker() == FATAL_APP_ERROR) {
-            eventBus.publish(new AppErrorEvent(ErrorLevel.FATAL, getThrowable(eventObject),
-                    eventObject.getFormattedMessage(), ""));
-        } else if (eventObject.getMarker() == FATAL_USER_ERROR) {
-            eventBus.publish(new UserErrorEvent(ErrorLevel.FATAL, getThrowable(eventObject),
-                    eventObject.getFormattedMessage(), ""));
-        }
+        errorManager.handle(eventObject);
     }
 
-    public void setEventBus(final DMDircMBassador eventBus) {
-        this.eventBus = eventBus;
+    public void setProgramErrorManager(final ProgramErrorManager errorManager) {
+        this.errorManager = errorManager;
     }
 }

src/com/dmdirc/logger/ProgramErrorFactory.java

@@ -43,10 +43,8 @@ public class ProgramErrorFactory {
 
     public ProgramError create(final ErrorLevel level, final String message,
             @Nullable final Throwable exception,
-            final Iterable<String> trace,
-            @Nullable final String details,
             final Date date,
             final boolean appError) {
-        return new ProgramError(level, message, exception, trace, details, date, eventBus, appError);
+        return new ProgramError(level, message, exception, date, eventBus, appError);
     }
 }

src/com/dmdirc/logger/ProgramErrorManager.java

@@ -23,14 +23,15 @@
 package com.dmdirc.logger;
 
 import com.dmdirc.DMDircMBassador;
-import com.dmdirc.events.AppErrorEvent;
 import com.dmdirc.events.ErrorEvent;
 import com.dmdirc.events.FatalProgramErrorEvent;
 import com.dmdirc.events.NonFatalProgramErrorEvent;
 import com.dmdirc.events.ProgramErrorDeletedEvent;
 import com.dmdirc.events.ProgramErrorEvent;
-import com.dmdirc.events.UserErrorEvent;
 import com.dmdirc.util.EventUtils;
+import com.dmdirc.util.LogUtils;
+
+import ch.qos.logback.classic.spi.ILoggingEvent;
 
 import com.google.common.base.Throwables;
 
@@ -43,9 +44,12 @@ import java.util.HashSet;
 import java.util.Set;
 import java.util.concurrent.CopyOnWriteArraySet;
 
+import javax.annotation.Nullable;
 import javax.inject.Inject;
 import javax.inject.Singleton;
 
+import org.slf4j.Marker;
+
 import net.engio.mbassy.listener.Handler;
 
 /**
@@ -77,19 +81,19 @@ public class ProgramErrorManager {
         eventBus.subscribe(this);
     }
 
-    @Handler
-    void handleAppError(final AppErrorEvent event) {
-        handleErrorEvent(event, true);
+    void handle(final ILoggingEvent event) {
+        final ProgramError error = addError(LogUtils.getErrorLevel(event.getLevel()),
+                event.getFormattedMessage(), LogUtils.getThrowable(event),
+                isAppError(event.getMarker()));
+        handleErrorEvent(error);
     }
 
-    @Handler
-    void handleUserError(final UserErrorEvent event) {
-        handleErrorEvent(event, false);
+    private boolean isAppError(@Nullable final Marker marker) {
+        return marker != null
+                && (marker == LogUtils.APP_ERROR || marker == LogUtils.FATAL_APP_ERROR);
     }
 
-    private void handleErrorEvent(final ErrorEvent event, final boolean appError) {
-        final ProgramError error = addError(event.getLevel(), event.getMessage(),
-                event.getThrowable(), event.getDetails(), appError);
+    void handleErrorEvent(final ProgramError error) {
         if (error.getLevel() == ErrorLevel.FATAL) {
             eventBus.publish(new FatalProgramErrorEvent(error));
         } else {
@@ -102,10 +106,7 @@ public class ProgramErrorManager {
     void handleProgramError(final NonFatalProgramErrorEvent event) {
         if (!event.isHandled()) {
             System.err.println(event.getError().getMessage());
-            System.err.println(event.getError().getDetails());
-            if (event.getError().getThrowable() != null) {
-                System.err.println(Throwables.getStackTraceAsString(event.getError().getThrowable()));
-            }
+            event.getError().getThrowableAsString().ifPresent(System.err::println);
         }
     }
 
@@ -115,16 +116,15 @@ public class ProgramErrorManager {
      * @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
      *
      * @since 0.6.3m1
      */
     private ProgramError addError(final ErrorLevel level, final String message,
-            final Throwable throwable, final String details, final boolean appError) {
+            final Throwable throwable, final boolean appError) {
 
         final ProgramError error = programErrorFactory.create(level, message, throwable,
-                getTrace(message, throwable), details, new Date(), appError);
+                new Date(), appError);
         errors.add(error);
         return error;
     }

src/com/dmdirc/logger/SentryErrorReporter.java

@@ -26,8 +26,8 @@ import com.dmdirc.interfaces.Connection;
 import com.dmdirc.util.ClientInfo;
 
 import java.util.Date;
+import java.util.Optional;
 
-import javax.annotation.Nullable;
 import javax.inject.Inject;
 import javax.inject.Singleton;
 
@@ -64,26 +64,18 @@ public class SentryErrorReporter {
      * @param level     The severity level of the error.
      * @param timestamp The timestamp that the error first occurred at.
      * @param exception The actual exception, if available.
-     * @param details   The details of the exception, if any.
      */
     public void sendException(
             final String message,
             final ErrorLevel level,
             final Date timestamp,
-            @Nullable final Throwable exception,
-            @Nullable final String details) {
+            final Optional<Throwable> exception) {
         final EventBuilder eventBuilder = newEventBuilder()
                 .withMessage(message)
                 .withLevel(getSentryLevel(level))
                 .withTimestamp(timestamp);
 
-        if (exception != null) {
-            eventBuilder.withSentryInterface(new ExceptionInterface(exception));
-        }
-
-        if (details != null) {
-            eventBuilder.withExtra("details", details);
-        }
+        exception.ifPresent(e -> eventBuilder.withSentryInterface(new ExceptionInterface(e)));
 
         send(eventBuilder.build());
     }

src/com/dmdirc/logger/SentryLoggingErrorManager.java

@@ -30,6 +30,9 @@ import com.dmdirc.events.ProgramErrorEvent;
 import com.dmdirc.events.ProgramErrorStatusEvent;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 
+import com.google.common.base.Throwables;
+
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Optional;
 import java.util.concurrent.ExecutorService;
@@ -87,7 +90,7 @@ public class SentryLoggingErrorManager {
     void handleErrorEvent(final ProgramErrorAddedEvent error) {
         final boolean appError = error.getError().isAppError();
         if (!isValidError(error.getError().getThrowable())
-                || !isValidSource(error.getError().getTrace())
+                || !isValidSource(error.getError().getThrowable())
                 || !appError) {
             error.getError().setReportStatus(ErrorReportStatus.NOT_APPLICABLE);
             eventBus.publish(new ProgramErrorStatusEvent(error.getError()));
@@ -119,10 +122,15 @@ public class SentryLoggingErrorManager {
      *
      * @return True if the source is valid, false otherwise
      */
-    private boolean isValidSource(final Collection<String> trace) {
-        final String line = getSourceLine(trace).orElse("").trim();
-        return line.startsWith("at com.dmdirc")
-                && !line.startsWith("at com.dmdirc.addons.ui_swing.DMDircEventQueue");
+    private boolean isValidSource(final Optional<Throwable> throwable) {
+        if (throwable.isPresent()) {
+            final String line = getSourceLine(Arrays.asList(
+                    Throwables.getStackTraceAsString(throwable.get()).split("\n")))
+                    .orElse("").trim();
+            return line.startsWith("at com.dmdirc")
+                    && !line.startsWith("at com.dmdirc.addons.ui_swing.DMDircEventQueue");
+        }
+        return false;
     }
 
     /**
@@ -149,16 +157,20 @@ public class SentryLoggingErrorManager {
      * @since 0.6.3m1
      * @return True if the exception may be reported, false otherwise
      */
-    private boolean isValidError(final Throwable exception) {
-        Throwable target = exception;
-        while (target != null) {
-            for (Class<?> bad : BANNED_EXCEPTIONS) {
-                if (bad.equals(target.getClass())) {
-                    return false;
+    private boolean isValidError(final Optional<Throwable> exception) {
+        if (exception.isPresent()) {
+            @SuppressWarnings("ThrowableResultOfMethodCallIgnored")
+            Throwable target = exception.get();
+            while (target != null) {
+                for (Class<?> bad : BANNED_EXCEPTIONS) {
+                    if (bad.equals(target.getClass())) {
+                        return false;
+                    }
                 }
+                target = target.getCause();
             }
-            target = target.getCause();
+            return true;
         }
-        return true;
+        return false;
     }
 }

src/com/dmdirc/ui/FatalErrorDialog.java

@@ -32,7 +32,6 @@ import java.awt.Dialog;
 import java.awt.Dimension;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
-import java.util.List;
 import java.util.concurrent.CountDownLatch;
 
 import javax.swing.BorderFactory;
@@ -157,14 +156,8 @@ public final class FatalErrorDialog extends JDialog implements ActionListener {
         icon = new ImageIcon(FatalErrorDialog.class.getResource("/com/dmdirc/res/error.png"));
 
         stacktraceField.setEditable(false);
-
-        final List<String> trace = error.getTrace();
-        if (!trace.isEmpty()) {
-            for (String line : trace) {
-                stacktraceField.append(line + '\n');
-            }
-            stacktraceField.setCaretPosition(0);
-        }
+        error.getThrowableAsString().ifPresent(stacktraceField::append);
+        stacktraceField.setCaretPosition(0);
 
         scrollPane.setViewportView(stacktraceField);
 

src/com/dmdirc/ui/core/errors/CoreErrorsDialogModel.java

@@ -33,8 +33,6 @@ import com.dmdirc.logger.ErrorReportStatus;
 import com.dmdirc.logger.ProgramError;
 import com.dmdirc.util.collections.ListenerList;
 
-import com.google.common.base.Throwables;
-
 import java.util.Collections;
 import java.util.Optional;
 import java.util.Set;
@@ -173,23 +171,12 @@ public class CoreErrorsDialogModel implements ErrorsDialogModel {
 
     private DisplayableError getDisplayableError(final ProgramError error) {
         final String details;
-        if (error.getDetails().isEmpty()) {
-            details = error.getMessage()
-                    + '\n' + getThrowableAsString(error.getThrowable());
+        if (error.getThrowableAsString().isPresent()) {
+            details = error.getMessage() + '\n' + error.getThrowableAsString().get();
         } else {
-            details = error.getMessage()
-                    + '\n' + error.getDetails()
-                    + '\n' + getThrowableAsString(error.getThrowable());
+            details = error.getMessage();
         }
         return new DisplayableError(error.getDate(), error.getMessage(), details,
                 error.getLevel(), error.getReportStatus(), error);
     }
-
-    private String getThrowableAsString(final Throwable throwable) {
-        if (throwable == null) {
-            return "";
-        } else {
-            return Throwables.getStackTraceAsString(throwable);
-        }
-    }
 }

test/com/dmdirc/logger/DiskLoggingErrorManagerTest.java

@@ -24,12 +24,14 @@ package com.dmdirc.logger;
 
 import com.dmdirc.DMDircMBassador;
 import com.dmdirc.config.ConfigBinder;
-import com.dmdirc.events.UserErrorEvent;
+import com.dmdirc.events.ProgramErrorEvent;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.tests.JimFsRule;
 
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.Date;
+import java.util.Optional;
 
 import org.junit.Before;
 import org.junit.Rule;
@@ -52,11 +54,18 @@ public class DiskLoggingErrorManagerTest {
     @Mock private DMDircMBassador eventBus;
     @Mock private AggregateConfigProvider config;
     @Mock private ConfigBinder configBinder;
+    @Mock private ProgramErrorEvent error;
+    @Mock private ProgramError programError;
 
     private DiskLoggingErrorManager instance;
 
     @Before
     public void setUp() throws Exception {
+        when(error.getTimestamp()).thenReturn(new Date().getTime());
+        when(error.getError()).thenReturn(programError);
+        when(programError.getThrowable()).thenReturn(Optional.of(new IllegalArgumentException()));
+        when(programError.getThrowableAsString()).thenReturn(Optional.of("test"));
+        when(programError.getLevel()).thenReturn(ErrorLevel.MEDIUM);
         when(config.getBinder()).thenReturn(configBinder);
         instance = new DiskLoggingErrorManager(jimFsRule.getFileSystem().getPath("/errors"),
                 eventBus);
@@ -78,11 +87,9 @@ public class DiskLoggingErrorManagerTest {
 
     @Test
     public void testHandleErrorEvent() throws Exception {
-        final UserErrorEvent error = new UserErrorEvent(ErrorLevel.MEDIUM,
-                new IllegalStateException(""), "", "");
         instance.initialise(config);
         instance.handleLoggingSetting(true);
-        final String logName = error.getTimestamp() + "-" + error.getLevel() + ".log";;
+        final String logName = error.getTimestamp() + "-" + error.getError().getLevel() + ".log";;
         assertFalse(Files.exists(jimFsRule.getFileSystem().getPath("/errors", logName)));
         instance.handleErrorEvent(error);
         final Path errorPath = jimFsRule.getFileSystem().getPath("/errors", logName);
@@ -92,12 +99,9 @@ public class DiskLoggingErrorManagerTest {
 
     @Test
     public void testHandleErrorEventNotLogging() throws Exception {
-        final UserErrorEvent error = new UserErrorEvent(ErrorLevel.MEDIUM,
-                new IllegalStateException(""),
-                "", "");
         instance.initialise(config);
         instance.handleLoggingSetting(false);
-        final String logName = error.getTimestamp() + "-" + error.getLevel() + ".log";;
+        final String logName = error.getTimestamp() + "-" + error.getError().getLevel() + ".log";;
         assertFalse(Files.exists(jimFsRule.getFileSystem().getPath("/errors", logName)));
         instance.handleErrorEvent(error);
         assertFalse(Files.exists(jimFsRule.getFileSystem().getPath("/errors", logName)));

test/com/dmdirc/logger/ErrorReportingRunnableTest.java

@@ -48,8 +48,7 @@ public class ErrorReportingRunnableTest {
         instance.run();
         verify(programError).setReportStatus(ErrorReportStatus.SENDING);
         verify(sentryErrorReporter).sendException(programError.getMessage(), programError
-                .getLevel(), programError.getDate(), programError.getThrowable(),
-                programError.getDetails());
+                .getLevel(), programError.getDate(), programError.getThrowable());
         verify(programError).setReportStatus(ErrorReportStatus.FINISHED);
     }
 }

test/com/dmdirc/logger/ProgramErrorTest.java

@@ -26,10 +26,7 @@ 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;
@@ -54,35 +51,31 @@ public class ProgramErrorTest {
 
     @Test(expected = NullPointerException.class)
     public void testConstructorNullErrorLevel() {
-        new ProgramError(null, "moo", null, Lists.newArrayList(), null, new Date(),
-                eventBus, true);
+        new ProgramError(null, "moo", null, new Date(),eventBus, true);
     }
 
     @Test(expected = NullPointerException.class)
     public void testConstructorNullDate() {
-        new ProgramError(ErrorLevel.HIGH, "moo", null, Lists.newArrayList(), null, null,
-                eventBus, true);
+        new ProgramError(ErrorLevel.HIGH, "moo", null, null, eventBus, true);
     }
 
     @Test
     public void testConstructorGood() {
         new ProgramError(ErrorLevel.HIGH, "moo", new UnsupportedOperationException(),
-                Lists.newArrayList(), null, new Date(), eventBus, true);
+                new Date(), eventBus, true);
     }
 
     @Test
     public void testGetLevel() {
         final ProgramError pe = new ProgramError(ErrorLevel.HIGH, "moo",
-                new UnsupportedOperationException(), Lists.newArrayList(), null, new Date(),
-                eventBus, true);
+                new UnsupportedOperationException(), new Date(), eventBus, true);
         assertEquals(ErrorLevel.HIGH, pe.getLevel());
     }
 
     @Test
     public void testGetMessage() {
         final ProgramError pe = new ProgramError(ErrorLevel.HIGH, "moo",
-                new UnsupportedOperationException(), Lists.newArrayList(), null, new Date(),
-                eventBus, true);
+                new UnsupportedOperationException(), new Date(), eventBus, true);
         assertEquals("moo", pe.getMessage());
     }
 
@@ -90,24 +83,21 @@ public class ProgramErrorTest {
     public void testGetDate() {
         final Date date = new Date();
         final ProgramError pe = new ProgramError(ErrorLevel.HIGH, "moo",
-                new UnsupportedOperationException(), Lists.newArrayList(), null, date,
-                eventBus, true);
+                new UnsupportedOperationException(), date, eventBus, true);
         assertEquals(date, pe.getDate());
     }
 
     @Test
     public void testIsAppError() {
         final ProgramError pe = new ProgramError(ErrorLevel.HIGH, "moo",
-                new UnsupportedOperationException(), Lists.newArrayList(), null, new Date(),
-                eventBus, true);
+                new UnsupportedOperationException(), new Date(), eventBus, true);
         assertTrue(pe.isAppError());
     }
 
     @Test
     public void testReportStatus() {
         final ProgramError pe = new ProgramError(ErrorLevel.HIGH, "moo",
-                new UnsupportedOperationException(), Lists.newArrayList(), null, new Date(),
-                eventBus, true);
+                new UnsupportedOperationException(), new Date(), eventBus, true);
         assertEquals(ErrorReportStatus.WAITING, pe.getReportStatus());
         pe.setReportStatus(null);
         assertEquals(ErrorReportStatus.WAITING, pe.getReportStatus());
@@ -124,33 +114,23 @@ public class ProgramErrorTest {
     @Test
     public void testToString() {
         final ProgramError pe = new ProgramError(ErrorLevel.HIGH, "moo",
-                new UnsupportedOperationException(), Lists.newArrayList(), null, new Date(),
-                eventBus, true);
+                new UnsupportedOperationException(), new Date(), eventBus, true);
         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(),
-                eventBus, true);
-        assertEquals(trace, pe.getTrace());
-    }
-
     @Test
     public void testEquals() {
         final Exception ex = new UnsupportedOperationException();
         final ProgramError pe1 = new ProgramError(ErrorLevel.LOW, "moo",
-                ex, Lists.newArrayList(), null, new Date(), eventBus, true);
+                ex, new Date(), eventBus, true);
         final ProgramError pe2 = new ProgramError(ErrorLevel.LOW, "moo",
-                ex, Lists.newArrayList(), null, new Date(), eventBus, true);
+                ex, new Date(), eventBus, true);
         final ProgramError pe3 = new ProgramError(ErrorLevel.MEDIUM, "moo",
-                ex, Lists.newArrayList(), null, new Date(), eventBus, true);
+                ex, new Date(), eventBus, true);
         final ProgramError pe4 = new ProgramError(ErrorLevel.LOW, "bar",
-                ex, Lists.newArrayList(), null, new Date(), eventBus, true);
+                ex, new Date(), eventBus, true);
         final ProgramError pe5 = new ProgramError(ErrorLevel.LOW, "moo",
-                null, Lists.newArrayList(), "Hello", new Date(), eventBus, true);
+                null, new Date(), eventBus, true);
 
         assertFalse(pe1.equals(null)); // NOPMD
         assertFalse(pe1.equals("moo"));

test/com/dmdirc/logger/SentryErrorReporterTest.java

@@ -25,6 +25,7 @@ package com.dmdirc.logger;
 import com.dmdirc.util.ClientInfo;
 
 import java.util.Date;
+import java.util.Optional;
 
 import org.junit.Before;
 import org.junit.BeforeClass;
@@ -57,6 +58,7 @@ public class SentryErrorReporterTest {
     @Mock private Raven raven;
     @Mock private ClientInfo clientInfo;
     @Captor private ArgumentCaptor<Event> eventCaptor;
+    private Optional<Throwable> throwable;
     private SentryErrorReporter sentryErrorReporter;
 
     @BeforeClass
@@ -69,12 +71,13 @@ public class SentryErrorReporterTest {
     @Before
     public void setUp() {
         when(ravenFactory.createRavenInstance(Matchers.<Dsn>anyObject())).thenReturn(raven);
+        throwable = Optional.of(new IllegalArgumentException());
         sentryErrorReporter = new SentryErrorReporter(clientInfo);
     }
 
     @Test
     public void testSendsMessage() {
-        sentryErrorReporter.sendException("message 123", ErrorLevel.MEDIUM, new Date(), null, null);
+        sentryErrorReporter.sendException("message 123", ErrorLevel.MEDIUM, new Date(), throwable);
         verify(raven).sendEvent(eventCaptor.capture());
         assertEquals("message 123", eventCaptor.getValue().getMessage());
     }
@@ -82,58 +85,51 @@ public class SentryErrorReporterTest {
     @Test
     public void testSendsTimestamp() {
         final Date date = new Date(561859200000l);
-        sentryErrorReporter.sendException("message 123", ErrorLevel.MEDIUM, date, null, null);
+        sentryErrorReporter.sendException("message 123", ErrorLevel.MEDIUM, date, throwable);
         verify(raven).sendEvent(eventCaptor.capture());
         assertEquals(date, eventCaptor.getValue().getTimestamp());
     }
 
     @Test
     public void testSendsLowLevelAsInfo() {
-        sentryErrorReporter.sendException("message 123", ErrorLevel.LOW, new Date(), null, null);
+        sentryErrorReporter.sendException("message 123", ErrorLevel.LOW, new Date(), throwable);
         verify(raven).sendEvent(eventCaptor.capture());
         assertEquals(Event.Level.INFO, eventCaptor.getValue().getLevel());
     }
 
     @Test
     public void testSendsMediumLevelAsWarning() {
-        sentryErrorReporter.sendException("message 123", ErrorLevel.MEDIUM, new Date(), null, null);
+        sentryErrorReporter.sendException("message 123", ErrorLevel.MEDIUM, new Date(), throwable);
         verify(raven).sendEvent(eventCaptor.capture());
         assertEquals(Event.Level.WARNING, eventCaptor.getValue().getLevel());
     }
 
     @Test
     public void testSendsHighLevelAsError() {
-        sentryErrorReporter.sendException("message 123", ErrorLevel.HIGH, new Date(), null, null);
+        sentryErrorReporter.sendException("message 123", ErrorLevel.HIGH, new Date(), throwable);
         verify(raven).sendEvent(eventCaptor.capture());
         assertEquals(Event.Level.ERROR, eventCaptor.getValue().getLevel());
     }
 
     @Test
     public void testSendsFatalLevelAsFatal() {
-        sentryErrorReporter.sendException("message 123", ErrorLevel.FATAL, new Date(), null, null);
+        sentryErrorReporter.sendException("message 123", ErrorLevel.FATAL, new Date(), throwable);
         verify(raven).sendEvent(eventCaptor.capture());
         assertEquals(Event.Level.FATAL, eventCaptor.getValue().getLevel());
     }
 
     @Test
     public void testSendsUnknownLevelAsInfo() {
-        sentryErrorReporter.sendException("message 123", ErrorLevel.UNKNOWN, new Date(), null, null);
+        sentryErrorReporter.sendException("message 123", ErrorLevel.UNKNOWN, new Date(), throwable);
         verify(raven).sendEvent(eventCaptor.capture());
         assertEquals(Event.Level.INFO, eventCaptor.getValue().getLevel());
     }
 
-    @Test
-    public void testAddsDetailsAsExtra() {
-        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");
-        sentryErrorReporter.sendException("message 123", ErrorLevel.UNKNOWN, new Date(), exception, null);
+        sentryErrorReporter.sendException("message 123", ErrorLevel.UNKNOWN, new Date(),
+                Optional.of(exception));
         verify(raven).sendEvent(eventCaptor.capture());
         final SentryInterface iface = eventCaptor.getValue().getSentryInterfaces()
                 .get(ExceptionInterface.EXCEPTION_INTERFACE);

test/com/dmdirc/logger/SentryLoggingErrorManagerTest.java

@@ -27,10 +27,10 @@ import com.dmdirc.config.ConfigBinder;
 import com.dmdirc.events.ProgramErrorAddedEvent;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 
-import com.google.common.collect.Lists;
 import com.google.common.util.concurrent.MoreExecutors;
 
 import java.util.Date;
+import java.util.Optional;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -62,10 +62,10 @@ public class SentryLoggingErrorManagerTest {
     public void setUp() throws Exception {
         when(appErrorEvent.getError()).thenReturn(appError);
         when(appError.isAppError()).thenReturn(true);
-        when(appError.getThrowable()).thenReturn(new IllegalStateException());
-        when(appError.getTrace()).thenReturn(Lists.newArrayList("at com.dmdirc.Main"));
+        when(appError.getThrowable()).thenReturn(Optional.of(new IllegalStateException()));
         when(userErrorEvent.getError()).thenReturn(userError);
         when(userError.isAppError()).thenReturn(false);
+        when(userError.getThrowable()).thenReturn(Optional.of(new IllegalStateException()));
         when(config.getBinder()).thenReturn(configBinder);
         instance = new SentryLoggingErrorManager(eventBus, sentryErrorReporter,
                 MoreExecutors.newDirectExecutorService());
@@ -78,48 +78,23 @@ public class SentryLoggingErrorManagerTest {
     public void testHandleErrorEvent() throws Exception {
         instance.handleErrorEvent(appErrorEvent);
         verify(sentryErrorReporter).sendException(anyString(), any(ErrorLevel.class),
-                any(Date.class), any(Throwable.class), anyString());
-    }
-
-    @Test
-    public void testHandleErrorEvent_DMDircEventQueue() throws Exception {
-        when(appError.getTrace()).thenReturn(Lists.newArrayList("at com.dmdirc.addons.ui_swing" +
-                ".DMDircEventQueue", "java.somethingelse"));
-        instance.handleErrorEvent(appErrorEvent);
-        verify(sentryErrorReporter, never()).sendException(anyString(), any(ErrorLevel.class),
-                any(Date.class), any(Throwable.class), anyString());
-    }
-
-    @Test
-    public void testHandleErrorEvent_No_com_dmdirc() throws Exception {
-        when(appError.getTrace()).thenReturn(Lists.newArrayList("java.util", "java.somethingelse"));
-        instance.handleErrorEvent(appErrorEvent);
-        verify(sentryErrorReporter, never()).sendException(anyString(), any(ErrorLevel.class),
-                any(Date.class), any(Throwable.class), anyString());
+                any(Date.class), any(Optional.class));
     }
 
     @Test
     public void testHandledErrorEvent_UserError() throws Exception {
         instance.handleErrorEvent(userErrorEvent);
         verify(sentryErrorReporter, never()).sendException(anyString(), any(ErrorLevel.class),
-                any(Date.class), any(Throwable.class), anyString());
-    }
-
-    @Test
-    public void testHandledErrorEvent_EmptyTrace() throws Exception {
-        when(appError.getTrace()).thenReturn(Lists.newArrayList());
-        instance.handleErrorEvent(appErrorEvent);
-        verify(sentryErrorReporter, never()).sendException(anyString(), any(ErrorLevel.class),
-                any(Date.class), any(Throwable.class), anyString());
+                any(Date.class), any(Optional.class));
     }
 
     @Test
     public void testHandledErrorEvent_BannedException() throws Exception {
         final Throwable throwable = new OutOfMemoryError();
-        when(appError.getThrowable()).thenReturn(throwable);
+        when(appError.getThrowable()).thenReturn(Optional.of(throwable));
         instance.handleErrorEvent(appErrorEvent);
         verify(sentryErrorReporter, never()).sendException(anyString(), any(ErrorLevel.class),
-                any(Date.class), eq(throwable), anyString());
+                any(Date.class), eq(Optional.of(throwable)));
     }
 
     @Test
@@ -128,7 +103,7 @@ public class SentryLoggingErrorManagerTest {
         instance.handleNoErrorReporting(false);
         instance.handleErrorEvent(appErrorEvent);
         verify(sentryErrorReporter, never()).sendException(anyString(), any(ErrorLevel.class),
-                any(Date.class), any(Throwable.class), anyString());
+                any(Date.class), any(Optional.class));
     }
 
     @Test
@@ -137,7 +112,7 @@ public class SentryLoggingErrorManagerTest {
         instance.handleNoErrorReporting(true);
         instance.handleErrorEvent(appErrorEvent);
         verify(sentryErrorReporter, never()).sendException(anyString(), any(ErrorLevel.class),
-                any(Date.class), any(Throwable.class), anyString());
+                any(Date.class), any(Optional.class));
     }
 
     @Test
@@ -146,7 +121,7 @@ public class SentryLoggingErrorManagerTest {
         instance.handleNoErrorReporting(false);
         instance.handleErrorEvent(appErrorEvent);
         verify(sentryErrorReporter).sendException(anyString(), any(ErrorLevel.class),
-                any(Date.class), any(Throwable.class), anyString());
+                any(Date.class), any(Optional.class));
     }
 
     @Test
@@ -155,6 +130,6 @@ public class SentryLoggingErrorManagerTest {
         instance.handleNoErrorReporting(true);
         instance.handleErrorEvent(appErrorEvent);
         verify(sentryErrorReporter, never()).sendException(anyString(), any(ErrorLevel.class),
-                any(Date.class), any(Throwable.class), anyString());
+                any(Date.class), any(Optional.class));
     }
 }