Track whether an error is handled/unhandled

Source/Bugsnag.h

@@ -132,6 +132,14 @@ static NSString *_Nonnull const BugsnagSeverityInfo = @"info";
     atSeverity:(NSString *_Nullable)severity
     __deprecated_msg("Use notify:block: instead and add the metadata and severity to the report directly.");
 
+/**
+ * Intended for use by other clients (React Native/Unity). Calling this method directly from
+ * iOS is not supported.
+ */
++ (void)internalClientNotify:(NSException *_Nonnull)exception
+                    withData:(NSDictionary *_Nullable)metaData
+                       block:(BugsnagNotifyBlock _Nullable)block;
+
 /** Add custom data to send to Bugsnag with every exception. If value is nil,
  *  delete the current value for attributeName
  *
@@ -193,4 +201,10 @@ static NSString *_Nonnull const BugsnagSeverityInfo = @"info";
 
 + (NSDateFormatter *_Nonnull)payloadDateFormatter;
 
++ (void)setSuspendThreadsForUserReported:(BOOL)suspendThreadsForUserReported;
++ (void)setReportWhenDebuggerIsAttached:(BOOL)reportWhenDebuggerIsAttached;
++ (void)setThreadTracingEnabled:(BOOL)threadTracingEnabled;
++ (void)setWriteBinaryImagesForUserReported:(BOOL)writeBinaryImagesForUserReported;
+
+
 @end

Source/Bugsnag.m

@@ -30,6 +30,7 @@
 #import "BugsnagNotifier.h"
 #import "BugsnagSink.h"
 #import "BugsnagLogger.h"
+#import "BSG_KSCrash.h"
 
 static BugsnagNotifier* bsg_g_bugsnag_notifier = NULL;
 
@@ -116,6 +117,7 @@ + (void)notify:(NSException *)exception
       withData:(NSDictionary*)metaData
     atSeverity:(NSString*)severity {
     [[self notifier] notifyException:exception
+                          atSeverity:BSGParseSeverity(severity)
                                block:^(BugsnagCrashReport * _Nonnull report) {
         report.depth = 1;
         report.metaData = [metaData BSG_mergedInto:
@@ -124,6 +126,14 @@ + (void)notify:(NSException *)exception
     }];
 }
 
++ (void)internalClientNotify:(NSException *_Nonnull)exception
+                    withData:(NSDictionary *_Nullable)metaData
+                       block:(BugsnagNotifyBlock _Nullable)block {
+    [self.notifier internalClientNotify:exception
+                               withData:metaData
+                                  block:block];
+}
+
 + (void) addAttribute:(NSString*)attributeName withValue:(id)value toTabWithName:(NSString*)tabName {
     if([self bugsnagStarted]) {
         [self.notifier.configuration.metaData addAttribute:attributeName withValue:value toTabWithName:tabName];
@@ -177,6 +187,22 @@ + (NSDateFormatter *)payloadDateFormatter {
     return formatter;
 }
 
++ (void)setSuspendThreadsForUserReported:(BOOL)suspendThreadsForUserReported {
+    [[BSG_KSCrash sharedInstance] setSuspendThreadsForUserReported:suspendThreadsForUserReported];
+}
+
++ (void)setReportWhenDebuggerIsAttached:(BOOL)reportWhenDebuggerIsAttached {
+    [[BSG_KSCrash sharedInstance] setReportWhenDebuggerIsAttached:reportWhenDebuggerIsAttached];
+}
+
++ (void)setThreadTracingEnabled:(BOOL)threadTracingEnabled {
+    [[BSG_KSCrash sharedInstance] setThreadTracingEnabled:threadTracingEnabled];
+}
+
++ (void)setWriteBinaryImagesForUserReported:(BOOL)writeBinaryImagesForUserReported {
+    [[BSG_KSCrash sharedInstance] setWriteBinaryImagesForUserReported:writeBinaryImagesForUserReported];
+}
+
 @end
 
 //

Source/BugsnagCrashReport.h

@@ -9,6 +9,7 @@
 #import <Foundation/Foundation.h>
 
 @class BugsnagConfiguration;
+@class BugsnagHandledState;
 
 typedef NS_ENUM(NSUInteger, BSGSeverity) {
     BSGSeverityError,
@@ -46,21 +47,23 @@ NSString *_Nonnull BSGFormatSeverity(BSGSeverity severity);
 - (instancetype _Nonnull)initWithKSReport:(NSDictionary *_Nonnull)report;
 
 /**
- *  Create a basic crash report from raw parts
+ *  Create a basic crash report from raw parts.
+ *
+ *  Assumes that the exception is handled.
  *
  *  @param name      The name of the exception
  *  @param message   The reason or message from the exception
  *  @param config    Bugsnag configuration
  *  @param metaData  additional data to attach to the report
- *  @param severity  severity of the error
+ *  @param handledState  the handled state of the error
  *
  *  @return a Bugsnag crash report
  */
 - (instancetype _Nonnull)initWithErrorName:(NSString *_Nonnull)name
                               errorMessage:(NSString *_Nonnull)message
                              configuration:(BugsnagConfiguration *_Nonnull)config
                                   metaData:(NSDictionary *_Nonnull)metaData
-                                  severity:(BSGSeverity)severity;
+                                  handledState:(BugsnagHandledState *_Nonnull)handledState;
 
 /**
  *  Serialize a crash report as a JSON payload
@@ -147,6 +150,11 @@ NSString *_Nonnull BSGFormatSeverity(BSGSeverity severity);
  *  generates a section on bugsnag, displaying key/value pairs
  */
 @property (nonatomic, readwrite, copy, nonnull) NSDictionary *metaData;
+/**
+ *  The event state (whether the error is handled/unhandled)
+ */
+@property (nonatomic, readonly, nonnull) BugsnagHandledState *handledState;
+
 /**
  *  Property overrides
  */

Source/BugsnagCrashReport.m

@@ -18,6 +18,7 @@
 #import "BugsnagLogger.h"
 #import "BSGSerialization.h"
 #import "BugsnagSystemInfo.h"
+#import "BugsnagHandledState.h"
 
 NSMutableDictionary *BSGFormatFrame(NSDictionary *frame,
                                     NSArray *binaryImages) {
@@ -279,6 +280,7 @@ @interface BugsnagCrashReport ()
  *  User-provided exception metadata
  */
 @property (nonatomic, readwrite, copy, nullable) NSDictionary *customException;
+
 @end
 
 @implementation BugsnagCrashReport
@@ -288,7 +290,6 @@ - (instancetype)initWithKSReport:(NSDictionary *)report {
       _notifyReleaseStages = [report valueForKeyPath:@"user.config.notifyReleaseStages"];
       _releaseStage = BSGParseReleaseStage(report);
 
-      // TODO BSG_KSCrash replacement
       _error = [report valueForKeyPath:@"crash.error"];
       _errorType = _error[@"type"];
       _errorClass = BSGParseErrorClass(_error, _errorType);
@@ -309,25 +310,40 @@ - (instancetype)initWithKSReport:(NSDictionary *)report {
       _groupingHash = BSGParseGroupingHash(report, _metaData);
       _overrides = [report valueForKeyPath:@"user.overrides"];
       _customException = BSGParseCustomException(report, [_errorClass copy], [_errorMessage copy]);
+
+      NSDictionary *recordedState = [report valueForKeyPath:@"user.handledState"];
+
+      if (recordedState) {
+          _handledState = [[BugsnagHandledState alloc] initWithDictionary:recordedState];
+      } else { // the event was unhandled.
+          BOOL isSignal = [@"signal" isEqualToString:_errorType];
+          SeverityReasonType severityReason = isSignal ? Signal : UnhandledException;
+          _handledState = [BugsnagHandledState handledStateWithSeverityReason:severityReason
+                                                                     severity:BSGSeverityError
+                                                                    attrValue:_errorClass];
+      }
+      _severity = _handledState.currentSeverity;
   }
   return self;
 }
 
-- (instancetype)initWithErrorName:(NSString *)name
-                     errorMessage:(NSString *)message
-                    configuration:(BugsnagConfiguration *)config
-                         metaData:(NSDictionary *)metaData
-                         severity:(BSGSeverity)severity {
+- (instancetype _Nonnull)initWithErrorName:(NSString *_Nonnull)name
+                              errorMessage:(NSString *_Nonnull)message
+                             configuration:(BugsnagConfiguration *_Nonnull)config
+                                  metaData:(NSDictionary *_Nonnull)metaData
+                              handledState:(BugsnagHandledState *_Nonnull)handledState {
     if (self = [super init]) {
         _errorClass = name;
         _errorMessage = message;
         _metaData = metaData ?: [NSDictionary new];
-        _severity = severity;
         _releaseStage = config.releaseStage;
         _notifyReleaseStages = config.notifyReleaseStages;
         _context = BSGParseContext(nil, metaData);
         _breadcrumbs = [config.breadcrumbs arrayValue];
         _overrides = [NSDictionary new];
+
+        _handledState = handledState;
+        _severity = handledState.currentSeverity;
     }
     return self;
 }
@@ -398,6 +414,11 @@ - (void)attachCustomStacktrace:(NSArray *)frames withType:(NSString *)type {
     [self setOverrideProperty:@"customStacktraceType" value:type];
 }
 
+- (void)setSeverity:(BSGSeverity)severity {
+    _severity = severity;
+    _handledState.currentSeverity = severity;
+}
+
 - (void)setOverrideProperty:(NSString *)key value:(id)value {
     NSMutableDictionary *metadata = [self.overrides mutableCopy];
     if (value) {
@@ -452,6 +473,20 @@ - (NSDictionary *)serializableValueWithTopLevelData:
   BSGDictSetSafeObject(event, [self app], @"app");
   BSGDictSetSafeObject(event, [self context], @"context");
   BSGDictInsertIfNotNil(event, self.groupingHash, @"groupingHash");
+
+    BSGDictSetSafeObject(event, @(self.handledState.unhandled), @"unhandled");
+
+    // serialize handled/unhandled into payload
+    NSMutableDictionary *severityReason = [NSMutableDictionary new];
+    NSString *reasonType = [BugsnagHandledState stringFromSeverityReason:self.handledState.calculateSeverityReasonType];
+    severityReason[@"type"] = reasonType;
+
+    if (self.handledState.attrKey && self.handledState.attrValue) {
+       severityReason[@"attributes"] = @{self.handledState.attrKey: self.handledState.attrValue};
+    }
+
+    BSGDictSetSafeObject(event, severityReason, @"severityReason");
+
 
   //  Inserted into `context` property
   [metaData removeObjectForKey:@"context"];

Source/BugsnagHandledState.h

@@ -0,0 +1,45 @@
+//
+//  BugsnagHandledState.h
+//  Bugsnag
+//
+//  Created by Jamie Lynch on 21/09/2017.
+//  Copyright © 2017 Bugsnag. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "BugsnagCrashReport.h"
+
+typedef NS_ENUM(NSUInteger, SeverityReasonType) {
+    UnhandledException,
+    Signal,
+    HandledError,
+    HandledException,
+    UserSpecifiedSeverity,
+    UserCallbackSetSeverity,
+    PromiseRejection
+};
+
+@interface BugsnagHandledState : NSObject
+
+@property (nonatomic, readonly) BOOL unhandled;
+@property (nonatomic, readonly) SeverityReasonType severityReasonType;
+@property (nonatomic, readonly) BSGSeverity originalSeverity;
+@property (nonatomic) BSGSeverity currentSeverity;
+@property (nonatomic, readonly) SeverityReasonType calculateSeverityReasonType;
+@property (nonatomic, readonly) NSString *attrValue;
+@property (nonatomic, readonly) NSString *attrKey;
+
++ (NSString *)stringFromSeverityReason:(SeverityReasonType)severityReason;
++ (SeverityReasonType)severityReasonFromString:(NSString *)string;
+
++ (instancetype)handledStateWithSeverityReason:(SeverityReasonType)severityReason;
+
++ (instancetype)handledStateWithSeverityReason:(SeverityReasonType)severityReason
+                                      severity:(BSGSeverity)severity
+                                     attrValue:(NSString *)attrValue;
+
+- (NSDictionary *)toJson;
+
+- (instancetype)initWithDictionary:(NSDictionary *)dict;
+
+@end