Proyectos de Subversion Iphone Microlearning

// Copyright 2021 Google LLC

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//      http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

#import <Foundation/Foundation.h>

#import "Crashlytics/Crashlytics/Controllers/FIRCLSMetricKitManager.h"

#if CLS_METRICKIT_SUPPORTED

#import "Crashlytics/Crashlytics/Controllers/FIRCLSManagerData.h"

#include "Crashlytics/Crashlytics/Handlers/FIRCLSMachException.h"

#include "Crashlytics/Crashlytics/Handlers/FIRCLSSignal.h"

#import "Crashlytics/Crashlytics/Helpers/FIRCLSCallStackTree.h"

#import "Crashlytics/Crashlytics/Helpers/FIRCLSFile.h"

#import "Crashlytics/Crashlytics/Helpers/FIRCLSLogger.h"

#import "Crashlytics/Crashlytics/Models/FIRCLSExecutionIdentifierModel.h"

#import "Crashlytics/Crashlytics/Models/FIRCLSInternalReport.h"

#import "Crashlytics/Crashlytics/Public/FirebaseCrashlytics/FIRCrashlytics.h"

#import "Crashlytics/Crashlytics/Public/FirebaseCrashlytics/FIRCrashlyticsReport.h"

@interface FIRCLSMetricKitManager ()

@property FBLPromise *metricKitDataAvailable;

@property FIRCLSExistingReportManager *existingReportManager;

@property FIRCLSFileManager *fileManager;

@property FIRCLSManagerData *managerData;

@property BOOL metricKitPromiseFulfilled;

@end

@implementation FIRCLSMetricKitManager

- (instancetype)initWithManagerData:(FIRCLSManagerData *)managerData

              existingReportManager:(FIRCLSExistingReportManager *)existingReportManager

                        fileManager:(FIRCLSFileManager *)fileManager {

  _existingReportManager = existingReportManager;

  _fileManager = fileManager;

  _managerData = managerData;

  _metricKitPromiseFulfilled = NO;

  return self;

}

/*

 * Registers the MetricKit manager to receive MetricKit reports by adding self to the

 * MXMetricManager subscribers. Also initializes the promise that we'll use to ensure that any

 * MetricKit report files are included in Crashylytics fatal reports. If no crash occurred on the

 * last run of the app, this promise is immediately resolved so that the upload of any nonfatal

 * events can proceed.

 */

- (void)registerMetricKitManager API_AVAILABLE(ios(14)) {

  [[MXMetricManager sharedManager] addSubscriber:self];

  self.metricKitDataAvailable = [FBLPromise pendingPromise];

  // If there was no crash on the last run of the app or there's no diagnostic report in the

  // MetricKit directory, then we aren't expecting a MetricKit diagnostic report and should resolve

  // the promise immediately. If MetricKit captured a fatal event and Crashlytics did not, then

  // we'll still process the MetricKit crash but won't upload it until the app restarts again.

  if (![self.fileManager didCrashOnPreviousExecution] ||

      ![self.fileManager metricKitDiagnosticFileExists]) {

    @synchronized(self) {

      [self fulfillMetricKitPromise];

    }

  }

  // If we haven't resolved this promise within three seconds, resolve it now so that we're not

  // waiting indefinitely for MetricKit payloads that won't arrive.

  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 3 * NSEC_PER_SEC), self.managerData.dispatchQueue,

                 ^{

                   @synchronized(self) {

                     if (!self.metricKitPromiseFulfilled) {

                       FIRCLSDebugLog(@"Resolving MetricKit promise after three seconds");

                       [self fulfillMetricKitPromise];

                     }

                   }

                 });

  FIRCLSDebugLog(@"Finished registering metrickit manager");

}

/*

 * This method receives diagnostic payloads from MetricKit whenever a fatal or nonfatal MetricKit

 * event occurs. If a fatal event, this method will be called when the app restarts. Since we're

 * including a MetricKit report file in the Crashlytics report to be sent to the backend, we need

 * to make sure that we process the payloads and write the included information to file before

 * the report is sent up. If this method is called due to a nonfatal event, it will be called

 * immediately after the event. Since we send nonfatal events on the next run of the app, we can

 * write out the information but won't need to resolve the promise.

 */

- (void)didReceiveDiagnosticPayloads:(NSArray<MXDiagnosticPayload *> *)payloads

    API_AVAILABLE(ios(14)) {

  BOOL processedFatalPayload = NO;

  for (MXDiagnosticPayload *diagnosticPayload in payloads) {

    if (!diagnosticPayload) {

      continue;

    }

    BOOL processedPayload = [self processMetricKitPayload:diagnosticPayload

                                           skipCrashEvent:processedFatalPayload];

    if (processedPayload && ([diagnosticPayload.crashDiagnostics count] > 0)) {

      processedFatalPayload = YES;

    }

  }

  // Once we've processed all the payloads, resolve the promise so that reporting uploading

  // continues. If there was not a crash on the previous run of the app, the promise will already

  // have been resolved.

  @synchronized(self) {

    [self fulfillMetricKitPromise];

  }

}

// Helper method to write a MetricKit payload's data to file.

- (BOOL)processMetricKitPayload:(MXDiagnosticPayload *)diagnosticPayload

                 skipCrashEvent:(BOOL)skipCrashEvent API_AVAILABLE(ios(14)) {

  BOOL writeFailed = NO;

  // Write out each type of diagnostic if it exists in the report

  BOOL hasCrash = [diagnosticPayload.crashDiagnostics count] > 0;

  BOOL hasHang = [diagnosticPayload.hangDiagnostics count] > 0;

  BOOL hasCPUException = [diagnosticPayload.cpuExceptionDiagnostics count] > 0;

  BOOL hasDiskWriteException = [diagnosticPayload.diskWriteExceptionDiagnostics count] > 0;

  // If there are no diagnostics in the report, return before writing out any files.

  if (!hasCrash && !hasHang && !hasCPUException && !hasDiskWriteException) {

    return false;

  }

  // MXDiagnosticPayload have both a timeStampBegin and timeStampEnd. Now that these events are

  // real-time, both refer to the same time - record both values anyway.

  NSTimeInterval beginSecondsSince1970 = [diagnosticPayload.timeStampBegin timeIntervalSince1970];

  NSTimeInterval endSecondsSince1970 = [diagnosticPayload.timeStampEnd timeIntervalSince1970];

  // Get file path for the active reports directory.

  NSString *activePath = [[self.fileManager activePath] stringByAppendingString:@"/"];

  // If there is a crash diagnostic in the payload, then this method was called for a fatal event.

  // Also ensure that there is a report from the last run of the app that we can write to.

  NSString *metricKitFatalReportFile;

  NSString *metricKitNonfatalReportFile;

  NSString *newestUnsentReportID =

      self.existingReportManager.newestUnsentReport.reportID

          ? [self.existingReportManager.newestUnsentReport.reportID stringByAppendingString:@"/"]

          : nil;

  NSString *currentReportID =

      [_managerData.executionIDModel.executionID stringByAppendingString:@"/"];

  BOOL crashlyticsFatalReported =

      ([diagnosticPayload.crashDiagnostics count] > 0) && (newestUnsentReportID != nil) &&

      ([self.fileManager

          fileExistsAtPath:[activePath stringByAppendingString:newestUnsentReportID]]);

  // Set the MetricKit fatal path appropriately depending on whether we also captured a Crashlytics

  // fatal event and whether the diagnostic report came from a fatal or nonfatal event.

  if (crashlyticsFatalReported) {

    metricKitFatalReportFile = [[activePath stringByAppendingString:newestUnsentReportID]

        stringByAppendingString:FIRCLSMetricKitFatalReportFile];

  } else {

    metricKitFatalReportFile = [[activePath stringByAppendingString:currentReportID]

        stringByAppendingString:FIRCLSMetricKitFatalReportFile];

  }

  metricKitNonfatalReportFile = [[activePath stringByAppendingString:currentReportID]

      stringByAppendingString:FIRCLSMetricKitNonfatalReportFile];

  if (!metricKitFatalReportFile || !metricKitNonfatalReportFile) {

    FIRCLSDebugLog(@"Error finding MetricKit files");

    return NO;

  }

  FIRCLSDebugLog(@"File paths for MetricKit report:  %@, %@", metricKitFatalReportFile,

                 metricKitNonfatalReportFile);

  if (hasCrash && ![_fileManager fileExistsAtPath:metricKitFatalReportFile]) {

    [_fileManager createFileAtPath:metricKitFatalReportFile contents:nil attributes:nil];

  }

  if ((hasHang | hasCPUException | hasDiskWriteException) &&

      ![_fileManager fileExistsAtPath:metricKitNonfatalReportFile]) {

    [_fileManager createFileAtPath:metricKitNonfatalReportFile contents:nil attributes:nil];

  }

  NSFileHandle *nonfatalFile =

      [NSFileHandle fileHandleForUpdatingAtPath:metricKitNonfatalReportFile];

  if ((hasHang | hasCPUException | hasDiskWriteException) && nonfatalFile == nil) {

    FIRCLSDebugLog(@"Unable to create or open nonfatal MetricKit file.");

    return false;

  }

  NSFileHandle *fatalFile = [NSFileHandle fileHandleForUpdatingAtPath:metricKitFatalReportFile];

  if (hasCrash && fatalFile == nil) {

    FIRCLSDebugLog(@"Unable to create or open fatal MetricKit file.");

    return false;

  }

  NSData *newLineData = [@"\n" dataUsingEncoding:NSUTF8StringEncoding];

  // For each diagnostic type, write out a section in the MetricKit report file. This section will

  // have subsections for threads, metadata, and event specific metadata.

  if (hasCrash && !skipCrashEvent) {

    // Write out time information to the MetricKit report file. Time needs to be a value for

    // backend serialization, so we write out end_time separately.

    MXCrashDiagnostic *crashDiagnostic = [diagnosticPayload.crashDiagnostics objectAtIndex:0];

    NSArray *threadArray = [self convertThreadsToArray:crashDiagnostic.callStackTree];

    NSDictionary *metadataDict = [self convertMetadataToDictionary:crashDiagnostic.metaData];

    NSString *nilString = @"";

    // On the backend, we process name, code name, and address into the subtitle of an issue.

    // Mach exception name and code should be preferred over signal name and code if available.

    const char *signalName = NULL;

    const char *signalCodeName = NULL;

    FIRCLSSignalNameLookup([crashDiagnostic.signal intValue], 0, &signalName, &signalCodeName);

    // signalName is the default name, so should never be NULL

    if (signalName == NULL) {

      signalName = "UNKNOWN";

    }

    if (signalCodeName == NULL) {

      signalCodeName = "";

    }

    const char *machExceptionName = NULL;

    const char *machExceptionCodeName = NULL;

#if CLS_MACH_EXCEPTION_SUPPORTED

    FIRCLSMachExceptionNameLookup(

        [crashDiagnostic.exceptionType intValue],

        (mach_exception_data_type_t)[crashDiagnostic.exceptionCode intValue], &machExceptionName,

        &machExceptionCodeName);

#endif

    if (machExceptionCodeName == NULL) {

      machExceptionCodeName = "";

    }

    NSString *name = machExceptionName != NULL ? [NSString stringWithUTF8String:machExceptionName]

                                               : [NSString stringWithUTF8String:signalName];

    NSString *codeName = machExceptionName != NULL

                             ? [NSString stringWithUTF8String:machExceptionCodeName]

                             : [NSString stringWithUTF8String:signalCodeName];

    NSDictionary *crashDictionary = @{

      @"metric_kit_fatal" : @{

        @"time" : [NSNumber numberWithLong:beginSecondsSince1970],

        @"end_time" : [NSNumber numberWithLong:endSecondsSince1970],

        @"metadata" : metadataDict,

        @"termination_reason" :

                (crashDiagnostic.terminationReason) ? crashDiagnostic.terminationReason : nilString,

        @"virtual_memory_region_info" : (crashDiagnostic.virtualMemoryRegionInfo)

            ? crashDiagnostic.virtualMemoryRegionInfo

            : nilString,

        @"exception_type" : crashDiagnostic.exceptionType,

        @"exception_code" : crashDiagnostic.exceptionCode,

        @"signal" : crashDiagnostic.signal,

        @"app_version" : crashDiagnostic.applicationVersion,

        @"code_name" : codeName,

        @"name" : name

      }

    };

    writeFailed = ![self writeDictionaryToFile:crashDictionary

                                          file:fatalFile

                                   newLineData:newLineData];

    writeFailed = writeFailed | ![self writeDictionaryToFile:@{@"threads" : threadArray}

                                                        file:fatalFile

                                                 newLineData:newLineData];

  }

  if (hasHang) {

    MXHangDiagnostic *hangDiagnostic = [diagnosticPayload.hangDiagnostics objectAtIndex:0];

    NSArray *threadArray = [self convertThreadsToArray:hangDiagnostic.callStackTree];

    NSDictionary *metadataDict = [self convertMetadataToDictionary:hangDiagnostic.metaData];

    NSDictionary *hangDictionary = @{

      @"exception" : @{

        @"type" : @"metrickit_nonfatal",

        @"name" : @"hang_event",

        @"time" : [NSNumber numberWithLong:beginSecondsSince1970],

        @"end_time" : [NSNumber numberWithLong:endSecondsSince1970],

        @"threads" : threadArray,

        @"metadata" : metadataDict,

        @"hang_duration" : [NSNumber numberWithDouble:[hangDiagnostic.hangDuration doubleValue]],

        @"app_version" : hangDiagnostic.applicationVersion

      }

    };

    writeFailed = ![self writeDictionaryToFile:hangDictionary

                                          file:nonfatalFile

                                   newLineData:newLineData];

  }

  if (hasCPUException) {

    MXCPUExceptionDiagnostic *cpuExceptionDiagnostic =

        [diagnosticPayload.cpuExceptionDiagnostics objectAtIndex:0];

    NSArray *threadArray = [self convertThreadsToArray:cpuExceptionDiagnostic.callStackTree];

    NSDictionary *metadataDict = [self convertMetadataToDictionary:cpuExceptionDiagnostic.metaData];

    NSDictionary *cpuDictionary = @{

      @"exception" : @{

        @"type" : @"metrickit_nonfatal",

        @"name" : @"cpu_exception_event",

        @"time" : [NSNumber numberWithLong:beginSecondsSince1970],

        @"end_time" : [NSNumber numberWithLong:endSecondsSince1970],

        @"threads" : threadArray,

        @"metadata" : metadataDict,

        @"total_cpu_time" :

            [NSNumber numberWithDouble:[cpuExceptionDiagnostic.totalCPUTime doubleValue]],

        @"total_sampled_time" :

            [NSNumber numberWithDouble:[cpuExceptionDiagnostic.totalSampledTime doubleValue]],

        @"app_version" : cpuExceptionDiagnostic.applicationVersion

      }

    };

    writeFailed = ![self writeDictionaryToFile:cpuDictionary

                                          file:nonfatalFile

                                   newLineData:newLineData];

  }

  if (hasDiskWriteException) {

    MXDiskWriteExceptionDiagnostic *diskWriteExceptionDiagnostic =

        [diagnosticPayload.diskWriteExceptionDiagnostics objectAtIndex:0];

    NSArray *threadArray = [self convertThreadsToArray:diskWriteExceptionDiagnostic.callStackTree];

    NSDictionary *metadataDict =

        [self convertMetadataToDictionary:diskWriteExceptionDiagnostic.metaData];

    NSDictionary *diskWriteDictionary = @{

      @"exception" : @{

        @"type" : @"metrickit_nonfatal",

        @"name" : @"disk_write_exception_event",

        @"time" : [NSNumber numberWithLong:beginSecondsSince1970],

        @"end_time" : [NSNumber numberWithLong:endSecondsSince1970],

        @"threads" : threadArray,

        @"metadata" : metadataDict,

        @"app_version" : diskWriteExceptionDiagnostic.applicationVersion,

        @"total_writes_caused" :

            [NSNumber numberWithDouble:[diskWriteExceptionDiagnostic.totalWritesCaused doubleValue]]

      }

    };

    writeFailed = ![self writeDictionaryToFile:diskWriteDictionary

                                          file:nonfatalFile

                                   newLineData:newLineData];

  }

  return !writeFailed;

}

/*

 * Required for MXMetricManager subscribers. Since we aren't currently collecting any MetricKit

 * metrics, this method is left empty.

 */

- (void)didReceiveMetricPayloads:(NSArray<MXMetricPayload *> *)payloads API_AVAILABLE(ios(13)) {

}

- (FBLPromise *)waitForMetricKitDataAvailable {

  FBLPromise *result = nil;

  @synchronized(self) {

    result = self.metricKitDataAvailable;

  }

  return result;

}

/*

 * Helper method to convert threads for a MetricKit fatal diagnostic event to an array of threads.

 */

- (NSArray *)convertThreadsToArray:(MXCallStackTree *)mxCallStackTree API_AVAILABLE(ios(14)) {

  FIRCLSCallStackTree *tree = [[FIRCLSCallStackTree alloc] initWithMXCallStackTree:mxCallStackTree];

  return [tree getArrayRepresentation];

}

/*

 * Helper method to convert threads for a MetricKit nonfatal diagnostic event to an array of frames.

 */

- (NSArray *)convertThreadsToArrayForNonfatal:(MXCallStackTree *)mxCallStackTree

    API_AVAILABLE(ios(14)) {

  FIRCLSCallStackTree *tree = [[FIRCLSCallStackTree alloc] initWithMXCallStackTree:mxCallStackTree];

  return [tree getFramesOfBlamedThread];

}

/*

 * Helper method to convert metadata for a MetricKit diagnostic event to a dictionary. MXMetadata

 * has a dictionaryRepresentation method but it is deprecated.

 */

- (NSDictionary *)convertMetadataToDictionary:(MXMetaData *)metadata API_AVAILABLE(ios(14)) {

  NSError *error = nil;

  NSDictionary *metadataDictionary =

      [NSJSONSerialization JSONObjectWithData:[metadata JSONRepresentation] options:0 error:&error];

  return metadataDictionary;

}

/*

 * Helper method to fulfill the metricKitDataAvailable promise and track that it has been fulfilled.

 */

- (void)fulfillMetricKitPromise {

  if (self.metricKitPromiseFulfilled) return;

  [self.metricKitDataAvailable fulfill:nil];

  self.metricKitPromiseFulfilled = YES;

}

/*

 * Helper method to write a dictionary of event information to file. Returns whether it succeeded.

 */

- (BOOL)writeDictionaryToFile:(NSDictionary *)dictionary

                         file:(NSFileHandle *)file

                  newLineData:(NSData *)newLineData {

  NSError *dataError = nil;

  NSData *data = [NSJSONSerialization dataWithJSONObject:dictionary options:0 error:&dataError];

  if (dataError) {

    FIRCLSDebugLog(@"Unable to write out dictionary.");

    return NO;

  }

  [file seekToEndOfFile];

  [file writeData:data];

  [file writeData:newLineData];

  return YES;

}

- (NSString *)getSignalName:(NSNumber *)signalCode {

  int signal = [signalCode intValue];

  switch (signal) {

    case SIGABRT:

      return @"SIGABRT";

    case SIGBUS:

      return @"SIGBUS";

    case SIGFPE:

      return @"SIGFPE";

    case SIGILL:

      return @"SIGILL";

    case SIGSEGV:

      return @"SIGSEGV";

    case SIGSYS:

      return @"SIGSYS";

    case SIGTRAP:

      return @"SIGTRAP";

    default:

      return @"UNKNOWN";

  }

  return @"UNKNOWN";

}

@end

#endif  // CLS_METRICKIT_SUPPORTED