Track handled unhandled (#59)

Author: fractalwrench

.gitignore

@@ -1,6 +1,7 @@
 .gradle
 build/
-
+*.iml
+out/
 #
 # Common IDE files
 #

src/main/java/com/bugsnag/Bugsnag.java

@@ -275,8 +275,9 @@ public boolean notify(Throwable throwable, Severity severity, Callback callback)
             return false;
         }
 
-        Report report = buildReport(throwable);
-        report.setSeverity(severity);
+        HandledState handledState = HandledState.newInstance(
+                HandledState.SeverityReasonType.REASON_USER_SPECIFIED, severity);
+        Report report = new Report(config, throwable, handledState);
         return notify(report, callback);
     }
 
@@ -293,6 +294,12 @@ public boolean notify(Report report) {
         return notify(report, null);
     }
 
+
+    boolean notify(Throwable throwable, HandledState handledState) {
+        Report report = new Report(config, throwable, handledState);
+        return notify(report, null);
+    }
+
     /**
      * Notify Bugsnag of an exception and provide custom diagnostic data
      * for this particular error report.

src/main/java/com/bugsnag/ExceptionHandler.java

@@ -3,6 +3,7 @@
 import java.lang.Thread.UncaughtExceptionHandler;
 import java.util.WeakHashMap;
 
+
 class ExceptionHandler implements UncaughtExceptionHandler {
     private final UncaughtExceptionHandler originalHandler;
     private final WeakHashMap<Bugsnag, Boolean> clientMap = new WeakHashMap<Bugsnag, Boolean>();
@@ -45,7 +46,10 @@ static void disable(Bugsnag bugsnag) {
     public void uncaughtException(Thread thread, Throwable throwable) {
         // Notify any subscribed clients of the uncaught exception
         for (Bugsnag bugsnag : clientMap.keySet()) {
-            bugsnag.notify(throwable, Severity.ERROR);
+
+            HandledState handledState = HandledState.newInstance(
+                    HandledState.SeverityReasonType.REASON_UNHANDLED_EXCEPTION, Severity.ERROR);
+            bugsnag.notify(throwable, handledState);
         }
 
         // Pass exception on to original exception handler

src/main/java/com/bugsnag/HandledState.java

@@ -0,0 +1,84 @@
+package com.bugsnag;
+
+final class HandledState {
+
+    enum SeverityReasonType {
+        REASON_UNHANDLED_EXCEPTION("unhandledException"),
+        REASON_HANDLED_EXCEPTION("handledException"),
+        REASON_USER_SPECIFIED("userSpecifiedSeverity"),
+        REASON_CALLBACK_SPECIFIED("userCallbackSetSeverity");
+
+        private final String name;
+
+        SeverityReasonType(String name) {
+            this.name = name;
+        }
+
+        @Override
+        public String toString() {
+            return name;
+        }
+    }
+
+    private final SeverityReasonType severityReasonType;
+    private final Severity originalSeverity;
+    private final boolean unhandled;
+
+    private Severity currentSeverity;
+
+    static HandledState newInstance(SeverityReasonType severityReasonType) {
+        return newInstance(severityReasonType, null);
+    }
+
+    static HandledState newInstance(SeverityReasonType severityReasonType, Severity severity) {
+        switch (severityReasonType) {
+            case REASON_UNHANDLED_EXCEPTION:
+                return new HandledState(severityReasonType, Severity.ERROR, true);
+            case REASON_HANDLED_EXCEPTION:
+                return new HandledState(severityReasonType, Severity.WARNING, false);
+            case REASON_USER_SPECIFIED:
+                return new HandledState(severityReasonType, severity, false);
+            default:
+                throw new IllegalArgumentException("Invalid arg for reason: " + severityReasonType);
+        }
+    }
+
+    private HandledState(SeverityReasonType severityReasonType,
+                         Severity currentSeverity, boolean unhandled) {
+        this.severityReasonType = severityReasonType;
+        this.originalSeverity = currentSeverity;
+        this.unhandled = unhandled;
+        this.currentSeverity = currentSeverity;
+    }
+
+    boolean isDefaultSeverity(Severity currentSeverity) {
+        return originalSeverity == currentSeverity;
+    }
+
+    boolean isUnhandled() {
+        return unhandled;
+    }
+
+    SeverityReasonType getSeverityReasonType() {
+        return severityReasonType;
+    }
+
+    Severity getOriginalSeverity() {
+        return originalSeverity;
+    }
+
+    SeverityReasonType calculateSeverityReasonType() {
+        return originalSeverity == currentSeverity
+                ? severityReasonType
+                : SeverityReasonType.REASON_CALLBACK_SPECIFIED;
+    }
+
+    Severity getCurrentSeverity() {
+        return currentSeverity;
+    }
+
+    void setCurrentSeverity(Severity severity) {
+        this.currentSeverity = severity;
+    }
+
+}

src/main/java/com/bugsnag/Report.java

@@ -10,13 +10,14 @@
 import java.util.Map;
 
 public class Report {
-    private static final String PAYLOAD_VERSION = "2";
+    private static final String PAYLOAD_VERSION = "3";
 
     private Configuration config;
 
     private String apiKey;
     private Throwable throwable;
-    private Severity severity = Severity.WARNING;
+    private final HandledState handledState;
+    private Severity severity;
     private String groupingHash;
     private Diagnostics diagnostics = new Diagnostics();
     private boolean shouldCancel = false;
@@ -28,8 +29,15 @@ public class Report {
      * @param throwable the error to create the report for.
      */
     protected Report(Configuration config, Throwable throwable) {
+        this(config, throwable, HandledState.newInstance(
+                HandledState.SeverityReasonType.REASON_HANDLED_EXCEPTION));
+    }
+
+    Report(Configuration config, Throwable throwable, HandledState handledState) {
         this.config = config;
         this.throwable = throwable;
+        this.handledState = handledState;
+        this.severity = handledState.getOriginalSeverity();
     }
 
     @Expose
@@ -55,6 +63,16 @@ protected List<Exception> getExceptions() {
         return exceptions;
     }
 
+    @Expose
+    boolean getUnhandled() {
+        return handledState.isUnhandled();
+    }
+
+    @Expose
+    SeverityReason getSeverityReason() {
+        return new SeverityReason(handledState.calculateSeverityReasonType().toString());
+    }
+
     @Expose
     protected List<ThreadState> getThreads() {
         return config.sendThreads ? ThreadState.getLiveThreads(config) : null;
@@ -216,6 +234,7 @@ public Report setGroupingHash(String groupingHash) {
      */
     public Report setSeverity(Severity severity) {
         this.severity = severity;
+        this.handledState.setCurrentSeverity(severity);
         return this;
     }
 
@@ -257,4 +276,17 @@ public Report cancel() {
     public boolean getShouldCancel() {
         return this.shouldCancel;
     }
+
+    static class SeverityReason {
+        private final String type;
+
+        SeverityReason(String type) {
+            this.type = type;
+        }
+
+        @Expose
+        String getType() {
+            return type;
+        }
+    }
 }

src/test/java/com/bugsnag/BugsnagTest.java

@@ -31,15 +31,7 @@ public void testNoDeliveryFails() {
     @Test
     public void testIgnoreClasses() {
         Bugsnag bugsnag = new Bugsnag("apikey");
-        bugsnag.setDelivery(new Delivery() {
-            @Override
-            public void deliver(Serializer serializer, Object object) {
-            }
-
-            @Override
-            public void close() {
-            }
-        });
+        bugsnag.setDelivery(BugsnagTestUtils.generateDelivery());
 
         // Ignore neither
         bugsnag.setIgnoreClasses();
@@ -60,15 +52,8 @@ public void close() {
     @Test
     public void testNotifyReleaseStages() {
         Bugsnag bugsnag = new Bugsnag("apikey");
-        bugsnag.setDelivery(new Delivery() {
-            @Override
-            public void deliver(Serializer serializer, Object object) {
-            }
+        bugsnag.setDelivery(BugsnagTestUtils.generateDelivery());
 
-            @Override
-            public void close() {
-            }
-        });
         bugsnag.setReleaseStage("production");
 
         // Never send
@@ -339,6 +324,7 @@ public void close() {
     @Test
     public void testCallbackCancel() {
         Bugsnag bugsnag = new Bugsnag("apikey");
+        bugsnag.setDelivery(BugsnagTestUtils.generateDelivery());
         bugsnag.addCallback(new Callback() {
             @Override
             public void beforeNotify(Report report) {

src/test/java/com/bugsnag/BugsnagTestUtils.java

@@ -0,0 +1,21 @@
+package com.bugsnag;
+
+import com.bugsnag.delivery.Delivery;
+import com.bugsnag.serialization.Serializer;
+
+class BugsnagTestUtils {
+
+    static Delivery generateDelivery() {
+        return new Delivery() {
+            @Override
+            public void deliver(Serializer serializer, Object object) {
+
+            }
+
+            @Override
+            public void close() {
+
+            }
+        };
+    }
+}