mirror of
https://github.com/firebase/firebase-ios-sdk
synced 2026-11-10 22:45:59 +05:45
347 lines
14 KiB
Objective-C
347 lines
14 KiB
Objective-C
// 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 <GoogleUtilities/GULUserDefaults.h>
|
|
|
|
#import "FirebasePerformance/Sources/Configurations/FPRConfigurations+Private.h"
|
|
#import "FirebasePerformance/Sources/Configurations/FPRConfigurations.h"
|
|
#import "FirebasePerformance/Sources/Configurations/FPRRemoteConfigFlags+Private.h"
|
|
#import "FirebasePerformance/Sources/Configurations/FPRRemoteConfigFlags.h"
|
|
|
|
#import "FirebasePerformance/Sources/FPRConsoleLogger.h"
|
|
|
|
#import "FirebaseCore/Extension/FirebaseCoreInternal.h"
|
|
|
|
#define ONE_DAY_SECONDS 24 * 60 * 60
|
|
|
|
static NSDate *FPRAppStartTime = nil;
|
|
|
|
typedef NS_ENUM(NSInteger, FPRConfigValueType) {
|
|
// Config value type String.
|
|
FPRConfigValueTypeString,
|
|
// Config value type Bool.
|
|
FPRConfigValueTypeBool,
|
|
// Config value type Integer.
|
|
FPRConfigValueTypeInteger,
|
|
// Config value type Float.
|
|
FPRConfigValueTypeFloat,
|
|
};
|
|
|
|
@interface FPRRemoteConfigFlags ()
|
|
|
|
/** @brief Represents if a fetch is currently in progress. */
|
|
@property(atomic) BOOL fetchInProgress;
|
|
|
|
/** @brief Dictionary of different config keys and value types. */
|
|
@property(nonatomic) NSDictionary<NSString *, NSNumber *> *configKeys;
|
|
|
|
/** @brief Last time the configs were cached. */
|
|
@property(nonatomic) NSDate *lastCachedTime;
|
|
|
|
@end
|
|
|
|
@implementation FPRRemoteConfigFlags
|
|
|
|
+ (void)load {
|
|
FPRAppStartTime = [NSDate date];
|
|
}
|
|
|
|
+ (nullable instancetype)sharedInstance {
|
|
static FPRRemoteConfigFlags *instance = nil;
|
|
static dispatch_once_t onceToken;
|
|
dispatch_once(&onceToken, ^{
|
|
FIRRemoteConfig *rc = [FIRRemoteConfig remoteConfigWithFIRNamespace:@"fireperf"
|
|
app:[FIRApp defaultApp]];
|
|
instance = [[FPRRemoteConfigFlags alloc] initWithRemoteConfig:rc];
|
|
});
|
|
return instance;
|
|
}
|
|
|
|
- (instancetype)initWithRemoteConfig:(FIRRemoteConfig *)config {
|
|
self = [super init];
|
|
if (self) {
|
|
_fprRemoteConfig = config;
|
|
_userDefaults = [FPRConfigurations sharedInstance].userDefaults;
|
|
self.fetchInProgress = NO;
|
|
|
|
// Set the overall delay to 5+random(25) making the config fetch delay at a max of 30 seconds
|
|
self.applicationStartTime = FPRAppStartTime;
|
|
self.appStartConfigFetchDelayInSeconds =
|
|
kFPRMinAppStartConfigFetchDelayInSeconds + arc4random_uniform(25);
|
|
|
|
NSMutableDictionary<NSString *, NSNumber *> *keysToCache =
|
|
[[NSMutableDictionary<NSString *, NSNumber *> alloc] init];
|
|
[keysToCache setObject:@(FPRConfigValueTypeInteger) forKey:@"fpr_log_source"];
|
|
[keysToCache setObject:@(FPRConfigValueTypeBool) forKey:@"fpr_enabled"];
|
|
[keysToCache setObject:@(FPRConfigValueTypeString) forKey:@"fpr_disabled_ios_versions"];
|
|
[keysToCache setObject:@(FPRConfigValueTypeInteger) forKey:@"fpr_rl_time_limit_sec"];
|
|
[keysToCache setObject:@(FPRConfigValueTypeInteger) forKey:@"fpr_rl_trace_event_count_fg"];
|
|
[keysToCache setObject:@(FPRConfigValueTypeInteger) forKey:@"fpr_rl_trace_event_count_bg"];
|
|
[keysToCache setObject:@(FPRConfigValueTypeInteger)
|
|
forKey:@"fpr_rl_network_request_event_count_fg"];
|
|
[keysToCache setObject:@(FPRConfigValueTypeInteger)
|
|
forKey:@"fpr_rl_network_request_event_count_bg"];
|
|
[keysToCache setObject:@(FPRConfigValueTypeFloat) forKey:@"fpr_vc_trace_sampling_rate"];
|
|
[keysToCache setObject:@(FPRConfigValueTypeFloat)
|
|
forKey:@"fpr_vc_network_request_sampling_rate"];
|
|
[keysToCache setObject:@(FPRConfigValueTypeFloat) forKey:@"fpr_vc_session_sampling_rate"];
|
|
[keysToCache setObject:@(FPRConfigValueTypeInteger)
|
|
forKey:@"fpr_session_gauge_cpu_capture_frequency_fg_ms"];
|
|
[keysToCache setObject:@(FPRConfigValueTypeInteger)
|
|
forKey:@"fpr_session_gauge_cpu_capture_frequency_bg_ms"];
|
|
[keysToCache setObject:@(FPRConfigValueTypeInteger)
|
|
forKey:@"fpr_session_gauge_memory_capture_frequency_fg_ms"];
|
|
[keysToCache setObject:@(FPRConfigValueTypeInteger)
|
|
forKey:@"fpr_session_gauge_memory_capture_frequency_bg_ms"];
|
|
[keysToCache setObject:@(FPRConfigValueTypeInteger) forKey:@"fpr_session_max_duration_min"];
|
|
[keysToCache setObject:@(FPRConfigValueTypeInteger) forKey:@"fpr_prewarm_detection"];
|
|
self.configKeys = [keysToCache copy];
|
|
|
|
[self update];
|
|
}
|
|
return self;
|
|
}
|
|
|
|
- (void)update {
|
|
// If a fetch is already happening, do not attempt a fetch.
|
|
if (self.fetchInProgress) {
|
|
return;
|
|
}
|
|
|
|
NSTimeInterval timeIntervalSinceLastFetch =
|
|
[self.fprRemoteConfig.lastFetchTime timeIntervalSinceNow];
|
|
NSTimeInterval timeSinceAppStart = [self.applicationStartTime timeIntervalSinceNow];
|
|
if ((ABS(timeSinceAppStart) > self.appStartConfigFetchDelayInSeconds) &&
|
|
(!self.fprRemoteConfig.lastFetchTime ||
|
|
ABS(timeIntervalSinceLastFetch) > kFPRConfigFetchIntervalInSeconds)) {
|
|
self.fetchInProgress = YES;
|
|
[self.fprRemoteConfig
|
|
fetchAndActivateWithCompletionHandler:^(FIRRemoteConfigFetchAndActivateStatus status,
|
|
NSError *_Nullable error) {
|
|
self.lastFetchStatus = self.fprRemoteConfig.lastFetchStatus;
|
|
if (status == FIRRemoteConfigFetchAndActivateStatusError) {
|
|
FPRLogError(kFPRConfigurationFetchFailure, @"Unable to fetch configurations.");
|
|
} else {
|
|
self.lastFetchedTime = self.fprRemoteConfig.lastFetchTime;
|
|
// If a fetch was successful,
|
|
// 1. Clear the old cache
|
|
[self resetCache];
|
|
// 2. Cache the new config values
|
|
[self cacheConfigValues];
|
|
}
|
|
self.fetchInProgress = NO;
|
|
}];
|
|
} else if (self.fprRemoteConfig.lastFetchTime) {
|
|
// Update the last fetched time to know that remote config fetch has happened in the past.
|
|
self.lastFetchedTime = self.fprRemoteConfig.lastFetchTime;
|
|
}
|
|
}
|
|
|
|
#pragma mark - Util methods.
|
|
|
|
- (void)resetCache {
|
|
[self.configKeys
|
|
enumerateKeysAndObjectsUsingBlock:^(NSString *key, NSNumber *valueType, BOOL *stop) {
|
|
NSString *cacheKey = [NSString stringWithFormat:@"%@.%@", kFPRConfigPrefix, key];
|
|
[self.userDefaults removeObjectForKey:cacheKey];
|
|
}];
|
|
}
|
|
|
|
- (void)cacheConfigValues {
|
|
[self.configKeys
|
|
enumerateKeysAndObjectsUsingBlock:^(NSString *key, NSNumber *valueType, BOOL *stop) {
|
|
FIRRemoteConfigValue *rcValue = [self.fprRemoteConfig configValueForKey:key];
|
|
|
|
// Cache only values that comes from remote.
|
|
if (rcValue != nil && rcValue.source == FIRRemoteConfigSourceRemote) {
|
|
FPRConfigValueType configValueType = [valueType integerValue];
|
|
NSString *cacheKey = [NSString stringWithFormat:@"%@.%@", kFPRConfigPrefix, key];
|
|
|
|
if (configValueType == FPRConfigValueTypeInteger) {
|
|
NSInteger integerValue = [[rcValue numberValue] integerValue];
|
|
[self.userDefaults setInteger:integerValue forKey:cacheKey];
|
|
} else if (configValueType == FPRConfigValueTypeFloat) {
|
|
float floatValue = [[rcValue numberValue] floatValue];
|
|
[self.userDefaults setFloat:floatValue forKey:cacheKey];
|
|
} else if (configValueType == FPRConfigValueTypeBool) {
|
|
BOOL boolValue = [rcValue boolValue];
|
|
[self.userDefaults setBool:boolValue forKey:cacheKey];
|
|
} else if (configValueType == FPRConfigValueTypeString) {
|
|
NSString *stringValue = [rcValue stringValue];
|
|
[self.userDefaults setObject:stringValue forKey:cacheKey];
|
|
}
|
|
|
|
self.lastCachedTime = [NSDate date];
|
|
}
|
|
}];
|
|
}
|
|
|
|
- (id)cachedValueForConfigFlag:(NSString *)configFlag {
|
|
// If the cached value is too old, return nil.
|
|
if (ABS([self.lastFetchedTime timeIntervalSinceNow]) > 7 * ONE_DAY_SECONDS) {
|
|
return nil;
|
|
}
|
|
|
|
NSString *cacheKey = [NSString stringWithFormat:@"%@.%@", kFPRConfigPrefix, configFlag];
|
|
id cachedValueObject = [self.userDefaults objectForKey:cacheKey];
|
|
return cachedValueObject;
|
|
}
|
|
|
|
#pragma mark - Config value fetch methods.
|
|
|
|
- (NSString *)getStringValueForFlag:(NSString *)flagName defaultValue:(NSString *)defaultValue {
|
|
id cachedValueObject = [self cachedValueForConfigFlag:flagName];
|
|
if ([cachedValueObject isKindOfClass:[NSString class]]) {
|
|
return (NSString *)cachedValueObject;
|
|
}
|
|
|
|
return defaultValue;
|
|
}
|
|
|
|
- (int)getIntValueForFlag:(NSString *)flagName defaultValue:(int)defaultValue {
|
|
id cachedValueObject = [self cachedValueForConfigFlag:flagName];
|
|
if (cachedValueObject) {
|
|
return [cachedValueObject intValue];
|
|
}
|
|
|
|
return defaultValue;
|
|
}
|
|
|
|
- (float)getFloatValueForFlag:(NSString *)flagName defaultValue:(float)defaultValue {
|
|
id cachedValueObject = [self cachedValueForConfigFlag:flagName];
|
|
if (cachedValueObject) {
|
|
return [cachedValueObject floatValue];
|
|
}
|
|
|
|
return defaultValue;
|
|
}
|
|
|
|
- (BOOL)getBoolValueForFlag:(NSString *)flagName defaultValue:(BOOL)defaultValue {
|
|
id cachedValueObject = [self cachedValueForConfigFlag:flagName];
|
|
if (cachedValueObject) {
|
|
return [cachedValueObject boolValue];
|
|
}
|
|
|
|
return defaultValue;
|
|
}
|
|
|
|
#pragma mark - Configuration methods.
|
|
|
|
- (int)logSourceWithDefaultValue:(int)logSource {
|
|
return [self getIntValueForFlag:@"fpr_log_source" defaultValue:logSource];
|
|
}
|
|
|
|
- (BOOL)performanceSDKEnabledWithDefaultValue:(BOOL)sdkEnabled {
|
|
/* Order of preference:
|
|
* 1. If remote config fetch was a failure, return NO.
|
|
* 2. If the fetch was successful, but RC does not have the value (not a remote value),
|
|
* return YES.
|
|
* 3. Else, use the value from RC.
|
|
*/
|
|
|
|
if (self.lastFetchStatus == FIRRemoteConfigFetchStatusFailure) {
|
|
return NO;
|
|
}
|
|
|
|
return [self getBoolValueForFlag:@"fpr_enabled" defaultValue:sdkEnabled];
|
|
}
|
|
|
|
- (NSSet<NSString *> *)sdkDisabledVersionsWithDefaultValue:(NSSet<NSString *> *)sdkVersions {
|
|
NSMutableSet<NSString *> *disabledVersions = [[NSMutableSet<NSString *> alloc] init];
|
|
|
|
NSString *sdkVersionsString = [[self getStringValueForFlag:@"fpr_disabled_ios_versions"
|
|
defaultValue:@""]
|
|
stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]];
|
|
if (sdkVersionsString.length > 0) {
|
|
NSArray<NSString *> *sdkVersionStrings = [sdkVersionsString componentsSeparatedByString:@";"];
|
|
for (NSString *sdkVersionString in sdkVersionStrings) {
|
|
NSString *trimmedString = [sdkVersionString
|
|
stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]];
|
|
if (trimmedString.length > 0) {
|
|
[disabledVersions addObject:trimmedString];
|
|
}
|
|
}
|
|
} else {
|
|
return sdkVersions;
|
|
}
|
|
|
|
return [disabledVersions copy];
|
|
}
|
|
|
|
#pragma mark - Rate limiting flags
|
|
|
|
- (int)rateLimitTimeDurationWithDefaultValue:(int)durationInSeconds {
|
|
return [self getIntValueForFlag:@"fpr_rl_time_limit_sec" defaultValue:durationInSeconds];
|
|
}
|
|
|
|
- (int)rateLimitTraceCountInForegroundWithDefaultValue:(int)eventCount {
|
|
return [self getIntValueForFlag:@"fpr_rl_trace_event_count_fg" defaultValue:eventCount];
|
|
}
|
|
|
|
- (int)rateLimitTraceCountInBackgroundWithDefaultValue:(int)eventCount {
|
|
return [self getIntValueForFlag:@"fpr_rl_trace_event_count_bg" defaultValue:eventCount];
|
|
}
|
|
|
|
- (int)rateLimitNetworkRequestCountInForegroundWithDefaultValue:(int)eventCount {
|
|
return [self getIntValueForFlag:@"fpr_rl_network_request_event_count_fg" defaultValue:eventCount];
|
|
}
|
|
|
|
- (int)rateLimitNetworkRequestCountInBackgroundWithDefaultValue:(int)eventCount {
|
|
return [self getIntValueForFlag:@"fpr_rl_network_request_event_count_bg" defaultValue:eventCount];
|
|
}
|
|
|
|
#pragma mark - Sampling flags
|
|
|
|
- (float)traceSamplingRateWithDefaultValue:(float)samplingRate {
|
|
return [self getFloatValueForFlag:@"fpr_vc_trace_sampling_rate" defaultValue:samplingRate];
|
|
}
|
|
|
|
- (float)networkRequestSamplingRateWithDefaultValue:(float)samplingRate {
|
|
return [self getFloatValueForFlag:@"fpr_vc_network_request_sampling_rate"
|
|
defaultValue:samplingRate];
|
|
}
|
|
|
|
#pragma mark - Session flags
|
|
|
|
- (float)sessionSamplingRateWithDefaultValue:(float)samplingRate {
|
|
return [self getFloatValueForFlag:@"fpr_vc_session_sampling_rate" defaultValue:samplingRate];
|
|
}
|
|
|
|
- (int)sessionGaugeCPUCaptureFrequencyInForegroundWithDefaultValue:(int)defaultFrequency {
|
|
return [self getIntValueForFlag:@"fpr_session_gauge_cpu_capture_frequency_fg_ms"
|
|
defaultValue:defaultFrequency];
|
|
}
|
|
|
|
- (int)sessionGaugeCPUCaptureFrequencyInBackgroundWithDefaultValue:(int)defaultFrequency {
|
|
return [self getIntValueForFlag:@"fpr_session_gauge_cpu_capture_frequency_bg_ms"
|
|
defaultValue:defaultFrequency];
|
|
}
|
|
|
|
- (int)sessionGaugeMemoryCaptureFrequencyInForegroundWithDefaultValue:(int)defaultFrequency {
|
|
return [self getIntValueForFlag:@"fpr_session_gauge_memory_capture_frequency_fg_ms"
|
|
defaultValue:defaultFrequency];
|
|
}
|
|
|
|
- (int)sessionGaugeMemoryCaptureFrequencyInBackgroundWithDefaultValue:(int)defaultFrequency {
|
|
return [self getIntValueForFlag:@"fpr_session_gauge_memory_capture_frequency_bg_ms"
|
|
defaultValue:defaultFrequency];
|
|
}
|
|
|
|
- (int)sessionMaxDurationWithDefaultValue:(int)maxDurationInMinutes {
|
|
return [self getIntValueForFlag:@"fpr_session_max_duration_min"
|
|
defaultValue:maxDurationInMinutes];
|
|
}
|
|
|
|
@end
|