Error Tracking

[[MParticle sharedInstance] logError:@"Login failed"
                           eventInfo:@{@"reason":@"Invalid username"}];

@try {      
    [self callNonExistingMethod];
}
@catch (NSException *ex) {
    [[MParticle sharedInstance] logException:ex];
}

// An exception reporting the topmost context at the moment of the exception
@try {      
    dictionary[@"key"] = nil;
}
@catch (NSException *ex) {        
    [[MParticle sharedInstance] logException:ex topmostContext:self];
}

// Assumes the PLCrashReporter library has been added to the project
@import CrashReporter;

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    
    // Initialize PLCrashReporter after the mParticle SDK has completed initialization
    NSNotificationCenter *notificationCenter = [NSNotificationCenter defaultCenter];
    [notificationCenter addObserver:self
                           selector:@selector(initCrashReporter)
                               name:mParticleDidFinishInitializing
                             object:nil];

    // Initialize mParticle
    MParticleOptions *options = [MParticleOptions optionsWithKey:@"REPLACE WITH APP KEY"
                                                          secret:@"REPLACE WITH APP SECRET"];
    [[MParticle sharedInstance] startWithOptions:options];

    return YES;
}

- (void) initCrashReporter {
    // It is strongly recommended that local symbolication only be enabled for non-release builds.
    // Use PLCrashReporterSymbolicationStrategyNone for release versions.
    PLCrashReporterConfig *config = [[PLCrashReporterConfig alloc] initWithSignalHandlerType: PLCrashReporterSignalHandlerTypeMach
                                                                       symbolicationStrategy: PLCrashReporterSymbolicationStrategyAll];
    PLCrashReporter *crashReporter = [[PLCrashReporter alloc] initWithConfiguration: config];

    // Enable the Crash Reporter.
    NSError *error;
    if (![crashReporter enableCrashReporterAndReturnError: &error]) {
        NSLog(@"Warning: Could not enable crash reporter: %@", error);
    }
}

if ([crashReporter hasPendingCrashReport]) {
    NSError *error;

    // Try loading the crash report.
    NSData *data = [crashReporter loadPendingCrashReportDataAndReturnError:&error];
    if (data == nil) {
        NSLog(@"Failed to load crash report data: %@", error);
        return;
    }

    // Retrieving crash reporter data.
    PLCrashReport *report = [[PLCrashReport alloc] initWithData:data error:&error];
    if (report == nil) {
        NSLog(@"Failed to parse crash report: %@", error);
        return;
    }

    // Generate text for crash report.
    NSString *text = [PLCrashReportTextFormatter stringValueForCrashReport:report withTextFormat:PLCrashReportTextFormatiOS];

    // Log crash report.
    [[MParticle sharedInstance] logCrash:@"Crash captured with PLCrashReporter" stackTrace:nil plCrashReport:text];
    
    // Purge the report.
    [crashReporter purgePendingCrashReport];
}

// Log crash report with a stack trace.
NSString *stackTrace = @"Stack Trace String";
[[MParticle sharedInstance] logCrash:@"Crash captured with PLCrashReporter" stackTrace:stackTrace plCrashReport:text];

@interface PLCrashReportTextFormatter (Private)

+ (NSString *) formatStackFrame:(PLCrashReportStackFrameInfo *)frameInfo
                     frameIndex:(NSUInteger)frameIndex
                         report:(PLCrashReport *)report
                           lp64:(BOOL)lp64;

@end

@interface PLCrashReportTextFormatter (StackTrace)

+ (NSString *)stringValueStackTraceForCrashReport:(PLCrashReport *)report;
+ (boolean_t)isLp64Report:(PLCrashReport *)report;

@end

@implementation PLCrashReportTextFormatter (StackTrace)

+ (NSString *)stringValueStackTraceForCrashReport:(PLCrashReport *)report {
    boolean_t lp64 = [PLCrashReportTextFormatter isLp64Report:report];
    NSMutableString *stackTrace = [@"" mutableCopy];
    if (report.exceptionInfo != nil && report.exceptionInfo.stackFrames != nil && [report.exceptionInfo.stackFrames count] > 0) {
        PLCrashReportExceptionInfo *exception = report.exceptionInfo;
        for (NSUInteger frame_idx = 0; frame_idx < [exception.stackFrames count]; frame_idx++) {
            PLCrashReportStackFrameInfo *frameInfo = [exception.stackFrames objectAtIndex: frame_idx];
            [stackTrace appendString: [PLCrashReportTextFormatter formatStackFrame: frameInfo frameIndex: frame_idx report: report lp64: lp64]];
        }
        [stackTrace appendString: @"\n"];
    }
    return stackTrace;
}

+ (boolean_t)isLp64Report:(PLCrashReport *)report {
    boolean_t lp64 = true; // quiesce GCC uninitialized value warning
    
    /* Map to Apple-style code type, and mark whether architecture is LP64 (64-bit) */
    NSString *codeType = nil;
    
    /* Attempt to derive the code type from the binary images */
    for (PLCrashReportBinaryImageInfo *image in report.images) {
        /* Skip images with no specified type */
        if (image.codeType == nil)
            continue;

        /* Skip unknown encodings */
        if (image.codeType.typeEncoding != PLCrashReportProcessorTypeEncodingMach)
            continue;
        
        switch (image.codeType.type) {
            case CPU_TYPE_ARM:
                codeType = @"ARM";
                lp64 = false;
                break;
                
            case CPU_TYPE_ARM64:
                codeType = @"ARM-64";
                lp64 = true;
                break;

            case CPU_TYPE_X86:
                codeType = @"X86";
                lp64 = false;
                break;

            case CPU_TYPE_X86_64:
                codeType = @"X86-64";
                lp64 = true;
                break;

            case CPU_TYPE_POWERPC:
                codeType = @"PPC";
                lp64 = false;
                break;
                
            default:
                // Do nothing, handled below.
                break;
        }

        /* Stop immediately if code type was discovered */
        if (codeType != nil)
            break;
    }

    /* If we were unable to determine the code type, fall back on the processor info's value. */
    if (codeType == nil && report.systemInfo.processorInfo.typeEncoding == PLCrashReportProcessorTypeEncodingMach) {
        switch (report.systemInfo.processorInfo.type) {
            case CPU_TYPE_ARM:
                codeType = @"ARM";
                lp64 = false;
                break;

            case CPU_TYPE_ARM64:
                codeType = @"ARM-64";
                lp64 = true;
                break;

            case CPU_TYPE_X86:
                codeType = @"X86";
                lp64 = false;
                break;

            case CPU_TYPE_X86_64:
                codeType = @"X86-64";
                lp64 = true;
                break;

            case CPU_TYPE_POWERPC:
                codeType = @"PPC";
                lp64 = false;
                break;

            default:
                codeType = [NSString stringWithFormat: @"Unknown (%llu)", report.systemInfo.processorInfo.type];
                lp64 = true;
                break;
        }
    }
    
    /* If we still haven't determined the code type, we're totally clueless. */
    if (codeType == nil) {
        codeType = @"Unknown";
        lp64 = true;
    }
    
    return lp64;
}

@end

// Leaving breadcrumbs as we parse an object that could throw an exception
- (void)parseResource:(Resource *)resource {
    MParticle *mParticle = [MParticle sharedInstance];

    @try {
        [mParticle leaveBreadcrumb:@"parsing began"];

        [mParticle leaveBreadcrumb:@"parsing title"];
        [resource parseTitle];

        [mParticle leaveBreadcrumb:@"parsing body"];
        [resource parseBody];

        [mParticle leaveBreadcrumb:@"parsing footer"];
        [resource parseFooter];

        [mParticle leaveBreadcrumb:@"parsing finished!"];
    }
    @catch (NSException *ex) {
        [mParticle logException:ex topmostContext:self];
    }
}