Proyectos de Subversion Iphone Microlearning

// Copyright 2020 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 "FirebasePerformance/Sources/Public/FirebasePerformance/FIRTrace.h"

#import "FirebasePerformance/Sources/AppActivity/FPRAppActivityTracker.h"

#import "FirebasePerformance/Sources/AppActivity/FPRSessionManager.h"

#import "FirebasePerformance/Sources/Common/FPRConstants.h"

#import "FirebasePerformance/Sources/Common/FPRDiagnostics.h"

#import "FirebasePerformance/Sources/Configurations/FPRConfigurations.h"

#import "FirebasePerformance/Sources/FPRClient.h"

#import "FirebasePerformance/Sources/FPRConsoleLogger.h"

#import "FirebasePerformance/Sources/FPRDataUtils.h"

#import "FirebasePerformance/Sources/Gauges/FPRGaugeManager.h"

#import "FirebasePerformance/Sources/Timer/FIRTrace+Internal.h"

#import "FirebasePerformance/Sources/Timer/FIRTrace+Private.h"

@interface FIRTrace ()

@property(nonatomic, copy, readwrite) NSString *name;

/** Custom attributes managed internally. */

@property(nonatomic) NSMutableDictionary<NSString *, NSString *> *customAttributes;

/** Serial queue to manage mutation of attributes. */

@property(nonatomic, readwrite) dispatch_queue_t customAttributesSerialQueue;

@property(nonatomic, readwrite) NSDate *startTime;

@property(nonatomic, readwrite) NSDate *stopTime;

/** Background activity tracker to know the background state of the trace. */

@property(nonatomic) FPRTraceBackgroundActivityTracker *backgroundActivityTracker;

/** Property that denotes if the trace is a stage. */

@property(nonatomic) BOOL isStage;

/** Stops an active stage that is currently active. */

- (void)stopActiveStage;

/**

 * Updates the current trace with the session id.

 * @param sessionDetails Updated session details of the currently active session.

 */

- (void)updateTraceWithSessionId:(FPRSessionDetails *)sessionDetails;

@end

@implementation FIRTrace

- (instancetype)initWithName:(NSString *)name {

  NSString *validatedName = FPRReservableName(name);

  FIRTrace *trace = [self initTraceWithName:validatedName];

  trace.internal = NO;

  return trace;

}

- (instancetype)initInternalTraceWithName:(NSString *)name {

  FIRTrace *trace = [self initTraceWithName:name];

  trace.internal = YES;

  return trace;

}

- (instancetype)initTraceWithName:(NSString *)name {

  BOOL tracingEnabled = [FPRConfigurations sharedInstance].isDataCollectionEnabled;

  if (!tracingEnabled) {

    FPRLogInfo(kFPRTraceDisabled, @"Trace feature is disabled.");

    return nil;

  }

  BOOL sdkEnabled = [[FPRConfigurations sharedInstance] sdkEnabled];

  if (!sdkEnabled) {

    FPRLogInfo(kFPRTraceDisabled, @"Dropping event since Performance SDK is disabled.");

    return nil;

  }

  FPRAssert(name != nil, @"Name cannot be nil");

  FPRAssert(name.length > 0, @"Name cannot be an empty string");

  if (name == nil || name.length == 0) {

    FPRLogError(kFPRTraceNoName, @"Failed to initialize because of a nil or zero length name.");

    return nil;

  }

  self = [super init];

  if (self) {

    _name = [name copy];

    _stages = [[NSMutableArray<FIRTrace *> alloc] init];

    _counterList = [[FPRCounterList alloc] init];

    _customAttributes = [[NSMutableDictionary<NSString *, NSString *> alloc] init];

    _customAttributesSerialQueue =

        dispatch_queue_create("com.google.perf.customAttributes.trace", DISPATCH_QUEUE_SERIAL);

    _sessionIdSerialQueue =

        dispatch_queue_create("com.google.perf.sessionIds.trace", DISPATCH_QUEUE_SERIAL);

    _activeSessions = [[NSMutableArray<FPRSessionDetails *> alloc] init];

    _isStage = NO;

    _fprClient = [FPRClient sharedInstance];

  }

  return self;

}

- (instancetype)init {

  FPRAssert(NO, @"Not a valid initializer.");

  return nil;

}

- (void)dealloc {

  // Track the number of traces that have started and not stopped.

  if (!self.isStage && [self isTraceStarted] && ![self isTraceStopped]) {

    FIRTrace *activeTrace = [FPRAppActivityTracker sharedInstance].activeTrace;

    [activeTrace incrementMetric:kFPRAppCounterNameTraceNotStopped byInt:1];

    FPRLogError(kFPRTraceStartedNotStopped, @"Trace name %@ started, not stopped", self.name);

  }

  FPRSessionManager *sessionManager = [FPRSessionManager sharedInstance];

  [sessionManager.sessionNotificationCenter removeObserver:self

                                                      name:kFPRSessionIdUpdatedNotification

                                                    object:sessionManager];

}

#pragma mark - Public instance methods

- (void)start {

  if (![self isTraceStarted]) {

    if (!self.isStage) {

      [[FPRGaugeManager sharedInstance] collectAllGauges];

    }

    self.startTime = [NSDate date];

    self.backgroundActivityTracker = [[FPRTraceBackgroundActivityTracker alloc] init];

    FPRSessionManager *sessionManager = [FPRSessionManager sharedInstance];

    if (!self.isStage) {

      [self updateTraceWithSessionId:[sessionManager.sessionDetails copy]];

      [sessionManager.sessionNotificationCenter addObserver:self

                                                   selector:@selector(sessionChanged:)

                                                       name:kFPRSessionIdUpdatedNotification

                                                     object:sessionManager];

    }

  } else {

    FPRLogError(kFPRTraceAlreadyStopped,

                @"Failed to start trace %@ because it has already been started and stopped.",

                self.name);

  }

}

- (void)startWithStartTime:(NSDate *)startTime {

  [self start];

  if (startTime) {

    self.startTime = startTime;

  }

}

- (void)stop {

  [self stopActiveStage];

  if ([self isTraceActive]) {

    self.stopTime = [NSDate date];

    [self.fprClient logTrace:self];

    if (!self.isStage) {

      [[FPRGaugeManager sharedInstance] collectAllGauges];

    }

  } else {

    FPRLogError(kFPRTraceNotStarted,

                @"Failed to stop the trace %@ because it has not been started.", self.name);

  }

  FPRSessionManager *sessionManager = [FPRSessionManager sharedInstance];

  [sessionManager.sessionNotificationCenter removeObserver:self

                                                      name:kFPRSessionIdUpdatedNotification

                                                    object:sessionManager];

}

- (void)cancel {

  [self stopActiveStage];

  if ([self isTraceActive]) {

    self.stopTime = [NSDate date];

  } else {

    FPRLogError(kFPRTraceNotStarted,

                @"Failed to stop the trace %@ because it has not been started.", self.name);

  }

}

- (NSTimeInterval)totalTraceTimeInterval {

  return [self.stopTime timeIntervalSinceDate:self.startTime];

}

- (NSTimeInterval)startTimeSinceEpoch {

  return [self.startTime timeIntervalSince1970];

}

- (BOOL)isCompleteAndValid {

  // Check if the trace time interval is valid.

  if (self.totalTraceTimeInterval <= 0) {

    return NO;

  }

  // Check if the counter list is valid.

  if (![self.counterList isValid]) {

    return NO;

  }

  // Check if the stages are valid.

  __block BOOL validTrace = YES;

  [self.stages enumerateObjectsUsingBlock:^(FIRTrace *stage, NSUInteger idx, BOOL *stop) {

    validTrace = [stage isCompleteAndValid];

    if (!validTrace) {

      *stop = YES;

    }

  }];

  return validTrace;

}

- (FPRTraceState)backgroundTraceState {

  FPRTraceBackgroundActivityTracker *backgroundActivityTracker = self.backgroundActivityTracker;

  if (backgroundActivityTracker) {

    return backgroundActivityTracker.traceBackgroundState;

  }

  return FPRTraceStateUnknown;

}

- (NSArray<FPRSessionDetails *> *)sessions {

  __block NSArray<FPRSessionDetails *> *sessionInfos = nil;

  dispatch_sync(self.sessionIdSerialQueue, ^{

    sessionInfos = [self.activeSessions copy];

  });

  return sessionInfos;

}

#pragma mark - Stage related methods

- (void)startStageNamed:(NSString *)stageName startTime:(NSDate *)startTime {

  if ([self isTraceActive]) {

    [self stopActiveStage];

    if (self.isInternal) {

      self.activeStage = [[FIRTrace alloc] initInternalTraceWithName:stageName];

      [self.activeStage startWithStartTime:startTime];

    } else {

      NSString *validatedStageName = FPRReservableName(stageName);

      if (validatedStageName.length > 0) {

        self.activeStage = [[FIRTrace alloc] initWithName:validatedStageName];

        [self.activeStage startWithStartTime:startTime];

      } else {

        FPRLogError(kFPRTraceEmptyName, @"The stage name cannot be empty.");

      }

    }

    self.activeStage.isStage = YES;

    // Do not track background activity tracker for stages.

    self.activeStage.backgroundActivityTracker = nil;

  } else {

    FPRLogError(kFPRTraceNotStarted,

                @"Failed to create stage %@ because the trace has not been started.", stageName);

  }

}

- (void)startStageNamed:(NSString *)stageName {

  [self startStageNamed:stageName startTime:nil];

}

- (void)stopActiveStage {

  if (self.activeStage) {

    [self.activeStage cancel];

    [self.stages addObject:self.activeStage];

    self.activeStage = nil;

  }

}

#pragma mark - Counter related methods

- (NSDictionary *)counters {

  return [self.counterList counters];

}

- (NSUInteger)numberOfCounters {

  return [self.counterList numberOfCounters];

}

#pragma mark - Metrics related methods

- (int64_t)valueForIntMetric:(nonnull NSString *)metricName {

  return [self.counterList valueForIntMetric:metricName];

}

- (void)setIntValue:(int64_t)value forMetric:(nonnull NSString *)metricName {

  if ([self isTraceActive]) {

    NSString *validatedMetricName = self.isInternal ? metricName : FPRReservableName(metricName);

    if (validatedMetricName.length > 0) {

      [self.counterList setIntValue:value forMetric:validatedMetricName];

      [self.activeStage setIntValue:value forMetric:validatedMetricName];

    } else {

      FPRLogError(kFPRTraceInvalidName, @"The metric name is invalid.");

    }

  } else {

    FPRLogError(kFPRTraceNotStarted,

                @"Failed to set value for metric %@ because trace %@ has not been started.",

                metricName, self.name);

  }

}

- (void)incrementMetric:(nonnull NSString *)metricName byInt:(int64_t)incrementValue {

  if ([self isTraceActive]) {

    NSString *validatedMetricName = self.isInternal ? metricName : FPRReservableName(metricName);

    if (validatedMetricName.length > 0) {

      [self.counterList incrementMetric:validatedMetricName byInt:incrementValue];

      [self.activeStage incrementMetric:validatedMetricName byInt:incrementValue];

      FPRLogDebug(kFPRClientMetricLogged, @"Incrementing metric %@ to %lld on trace %@",

                  validatedMetricName, [self valueForIntMetric:metricName], self.name);

    } else {

      FPRLogError(kFPRTraceInvalidName, @"The metric name is invalid.");

    }

  } else {

    FPRLogError(kFPRTraceNotStarted,

                @"Failed to increment the trace metric %@ because trace %@ has not been started.",

                metricName, self.name);

  }

}

- (void)deleteMetric:(nonnull NSString *)metricName {

  if ([self isTraceActive]) {

    [self.counterList deleteMetric:metricName];

    [self.activeStage deleteMetric:metricName];

  }

}

#pragma mark - Custom attributes related methods

- (NSDictionary<NSString *, NSString *> *)attributes {

  return [self.customAttributes copy];

}

- (void)setValue:(NSString *)value forAttribute:(nonnull NSString *)attribute {

  BOOL canAddAttribute = YES;

  if ([self isTraceStopped]) {

    FPRLogError(kFPRTraceAlreadyStopped,

                @"Failed to set attribute %@ because trace %@ has already stopped.", attribute,

                self.name);

    canAddAttribute = NO;

  }

  NSString *validatedName = FPRReservableAttributeName(attribute);

  NSString *validatedValue = FPRValidatedAttributeValue(value);

  if (validatedName == nil) {

    FPRLogError(kFPRAttributeNoName,

                @"Failed to initialize because of a nil or zero length attribute name.");

    canAddAttribute = NO;

  }

  if (validatedValue == nil) {

    FPRLogError(kFPRAttributeNoValue,

                @"Failed to initialize because of a nil or zero length attribute value.");

    canAddAttribute = NO;

  }

  if (self.customAttributes.allKeys.count >= kFPRMaxTraceCustomAttributesCount) {

    FPRLogError(kFPRMaxAttributesReached,

                @"Only %d attributes allowed. Already reached maximum attribute count.",

                kFPRMaxTraceCustomAttributesCount);

    canAddAttribute = NO;

  }

  if (canAddAttribute) {

    // Ensure concurrency during update of attributes.

    dispatch_sync(self.customAttributesSerialQueue, ^{

      self.customAttributes[validatedName] = validatedValue;

    });

  }

  FPRLogDebug(kFPRClientMetricLogged, @"Setting attribute %@ to %@ on trace %@", validatedName,

              validatedValue, self.name);

}

- (NSString *)valueForAttribute:(NSString *)attribute {

  // TODO(b/175053654): Should this be happening on the serial queue for thread safety?

  return self.customAttributes[attribute];

}

- (void)removeAttribute:(NSString *)attribute {

  if ([self isTraceStopped]) {

    FPRLogError(kFPRTraceNotStarted,

                @"Failed to remove attribute %@ because trace %@ has already stopped.", attribute,

                self.name);

    return;

  }

  [self.customAttributes removeObjectForKey:attribute];

}

#pragma mark - Utility methods

- (void)sessionChanged:(NSNotification *)notification {

  if ([self isTraceActive]) {

    NSDictionary<NSString *, FPRSessionDetails *> *userInfo = notification.userInfo;

    FPRSessionDetails *sessionDetails = [userInfo valueForKey:kFPRSessionIdNotificationKey];

    if (sessionDetails) {

      [self updateTraceWithSessionId:sessionDetails];

    }

  }

}

- (void)updateTraceWithSessionId:(FPRSessionDetails *)sessionDetails {

  dispatch_sync(self.sessionIdSerialQueue, ^{

    [self.activeSessions addObject:sessionDetails];

  });

}

- (BOOL)isTraceStarted {

  return self.startTime != nil;

}

- (BOOL)isTraceStopped {

  return (self.startTime != nil && self.stopTime != nil);

}

- (BOOL)isTraceActive {

  return (self.startTime != nil && self.stopTime == nil);

}

@end