Version 2.13.0

CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to the LaunchDarkly iOS SDK will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org).
 
+## [2.13.0] - 2018-06-01
+### Added
+- New property `inlineUserInEvents` in `LDConfig`. When `YES` includes the full user (excluding private attributes) in analytics `feature` and `custom` events. When `NO` includes only the `userKey`. Default: `NO`.
+- Calling `start` or `updateUser` (when started) on `LDClient` logs an analytics `identify` event. `identify` events contain the full user (excluding private attributes) regardless of `inlineUserInEvents`.
+- Adds analytics `summary` event used to track feature flag requests to the SDK.
+- Adds analytics `debug` event available to assist with debugging when requested from the website Debugger.
+
+### Changed
+- Changes analytics `feature` events so that they are only sent when requested via the website Dashboard.
+- Fixed a defect preventing the SDK from updating correctly on a `put` streaming event when there are no flag changes.
+- Fixed a defect on `watchOS` causing the SDK to report analytics dates incorrectly.
+
 ## [2.12.1] - 2018-04-23
 ### Changed
 - Clears selected warnings in CocoaPods project

Darkly/DarklyConstants.m

@@ -4,7 +4,7 @@
 
 #import "DarklyConstants.h"
 
-NSString * const kClientVersion = @"2.12.1";
+NSString * const kClientVersion = @"2.13.0";
 NSString * const kBaseUrl = @"https://app.launchdarkly.com";
 NSString * const kEventsUrl = @"https://mobile.launchdarkly.com";
 NSString * const kStreamUrl = @"https://clientstream.launchdarkly.com";
@@ -35,7 +35,11 @@
 int const kDefaultFlushInterval = 30;
 int const kMinimumFlushIntervalMillis = 0;
 int const kDefaultPollingInterval = 300;
+#if DEBUG
+int const kMinimumPollingInterval = 30;
+#else
 int const kMinimumPollingInterval = 300;
+#endif
 int const kDefaultBackgroundFetchInterval = 3600;
 int const kMinimumBackgroundFetchInterval = 900;
 int const kMillisInSecs = 1000;

Darkly/LDClient.m

@@ -11,6 +11,9 @@
 #import "DarklyConstants.h"
 #import "NSThread+MainExecutable.h"
 #import "LDThrottler.h"
+#import "LDFlagConfigModel.h"
+#import "LDFlagConfigValue.h"
+#import "LDFlagConfigTracker.h"
 
 @interface LDClient()
 @property (nonatomic, assign) BOOL isOnline;
@@ -49,6 +52,11 @@ +(LDClient *)sharedInstance
     return sharedLDClient;
 }
 
+-(void)setLdUser:(LDUserModel*)user {
+    _ldUser = user;
+    [[LDDataManager sharedManager] createIdentifyEventWithUser:_ldUser config:self.ldConfig];
+}
+
 -(BOOL)start:(LDConfigBuilder *)inputConfigBuilder userBuilder:(LDUserBuilder *)inputUserBuilder {
     return [self start:[inputConfigBuilder build] withUserBuilder:inputUserBuilder];
 }
@@ -103,140 +111,149 @@ - (LDUserBuilder *)currentUserBuilder {
     }
 }
 
-- (BOOL)boolVariation:(NSString *)featureKey fallback:(BOOL)fallback{
-    DEBUG_LOG(@"LDClient boolVariation method called for feature=%@ and fallback=%d", featureKey, fallback);
-    if (![featureKey isKindOfClass:[NSString class]]) {
-        NSLog(@"featureKey should be an NSString. Returning fallback value");
+- (BOOL)boolVariation:(NSString *)flagKey fallback:(BOOL)fallback{
+    DEBUG_LOG(@"LDClient boolVariation method called for flagKey=%@ and fallback=%d", flagKey, fallback);
+    if (![flagKey isKindOfClass:[NSString class]]) {
+        NSLog(@"flagKey should be an NSString. Returning fallback value");
         return fallback;
     }
-    if (self.clientStarted) {
-        BOOL flagExists = [self.ldUser doesFlagExist: featureKey];
-        NSObject *flagValue = [self.ldUser flagValue: featureKey];
-        BOOL returnValue = fallback;
-        if ([flagValue isKindOfClass:[NSNumber class]] && flagExists) {
-            returnValue = [(NSNumber *)flagValue boolValue];
-        }
-
-        [[LDDataManager sharedManager] createFeatureEvent: featureKey keyValue:[NSNumber numberWithBool:returnValue] defaultKeyValue:[NSNumber numberWithBool:fallback] user:self.ldUser config:self.ldConfig];
-        return returnValue;
-    } else {
+    if (!self.clientStarted) {
         DEBUG_LOGX(@"LDClient not started yet!");
+        return fallback;
     }
-    return fallback;
+
+    LDFlagConfigValue *flagConfigValue = [self.ldUser.flagConfig flagConfigValueForFlagKey:flagKey];
+    BOOL returnValue = flagConfigValue.value && [flagConfigValue.value isKindOfClass:[NSNumber class]] ? [flagConfigValue.value boolValue] : fallback;
+
+    [[LDDataManager sharedManager] createFlagEvaluationEventsWithFlagKey:flagKey
+                                                       reportedFlagValue:@(returnValue)
+                                                         flagConfigValue:flagConfigValue
+                                                        defaultFlagValue:@(fallback)
+                                                                    user:self.ldUser
+                                                                  config:self.ldConfig];
+    return returnValue;
 }
 
-- (NSNumber*)numberVariation:(NSString *)featureKey fallback:(NSNumber*)fallback{
-    DEBUG_LOG(@"LDClient numberVariation method called for feature=%@ and fallback=%@", featureKey, fallback);
-    if (![featureKey isKindOfClass:[NSString class]]) {
-        NSLog(@"featureKey should be an NSString. Returning fallback value");
+- (NSNumber*)numberVariation:(NSString *)flagKey fallback:(NSNumber*)fallback{
+    DEBUG_LOG(@"LDClient numberVariation method called for flagKey=%@ and fallback=%@", flagKey, fallback);
+    if (![flagKey isKindOfClass:[NSString class]]) {
+        NSLog(@"flagKey should be an NSString. Returning fallback value");
         return fallback;
     }
-    if (self.clientStarted) {
-        BOOL flagExists = [self.ldUser doesFlagExist: featureKey];
-        NSObject *flagValue = [self.ldUser flagValue: featureKey];
-        NSNumber *returnValue = fallback;
-        if ([flagValue isKindOfClass:[NSNumber class]] && flagExists) {
-            returnValue = (NSNumber *)flagValue;
-        }
-
-        [[LDDataManager sharedManager] createFeatureEvent: featureKey keyValue:returnValue defaultKeyValue:fallback user:self.ldUser config:self.ldConfig];
-        return returnValue;
-    } else {
+    if (!self.clientStarted) {
         DEBUG_LOGX(@"LDClient not started yet!");
+        return fallback;
     }
-    return fallback;
+
+    LDFlagConfigValue *flagConfigValue = [self.ldUser.flagConfig flagConfigValueForFlagKey:flagKey];
+    NSNumber *returnValue = flagConfigValue.value && [flagConfigValue.value isKindOfClass:[NSNumber class]] ? flagConfigValue.value : fallback;
+
+    [[LDDataManager sharedManager] createFlagEvaluationEventsWithFlagKey:flagKey
+                                                       reportedFlagValue:returnValue
+                                                         flagConfigValue:flagConfigValue
+                                                        defaultFlagValue:fallback
+                                                                    user:self.ldUser
+                                                                  config:self.ldConfig];
+    return returnValue;
 }
 
-- (double)doubleVariation:(NSString *)featureKey fallback:(double)fallback {
-    DEBUG_LOG(@"LDClient doubleVariation method called for feature=%@ and fallback=%f", featureKey, fallback);
-    if (![featureKey isKindOfClass:[NSString class]]) {
-        NSLog(@"featureKey should be an NSString. Returning fallback value");
+- (double)doubleVariation:(NSString *)flagKey fallback:(double)fallback {
+    DEBUG_LOG(@"LDClient doubleVariation method called for flagKey=%@ and fallback=%f", flagKey, fallback);
+    if (![flagKey isKindOfClass:[NSString class]]) {
+        NSLog(@"flagKey should be an NSString. Returning fallback value");
         return fallback;
     }
     if (!self.clientStarted) {
         DEBUG_LOGX(@"LDClient not started yet!");
         return fallback;
     }
-    BOOL flagExists = [self.ldUser doesFlagExist: featureKey];
-    id flagValue = [self.ldUser flagValue: featureKey];
-    double returnValue = fallback;
-    if (flagExists && [flagValue isKindOfClass:[NSNumber class]]) {
-        returnValue = [((NSNumber *)flagValue) doubleValue];
-    }
-
-    [[LDDataManager sharedManager] createFeatureEvent:featureKey keyValue:[NSNumber numberWithDouble:returnValue] defaultKeyValue:[NSNumber numberWithDouble:fallback] user:self.ldUser config:self.ldConfig];
+
+    LDFlagConfigValue *flagConfigValue = [self.ldUser.flagConfig flagConfigValueForFlagKey:flagKey];
+    double returnValue = flagConfigValue.value && [flagConfigValue.value isKindOfClass:[NSNumber class]] ? [flagConfigValue.value doubleValue] : fallback;
+
+    [[LDDataManager sharedManager] createFlagEvaluationEventsWithFlagKey:flagKey
+                                                       reportedFlagValue:@(returnValue)
+                                                         flagConfigValue:flagConfigValue
+                                                        defaultFlagValue:@(fallback)
+                                                                    user:self.ldUser
+                                                                  config:self.ldConfig];
     return returnValue;
 }
 
-- (NSString*)stringVariation:(NSString *)featureKey fallback:(NSString*)fallback{
-    DEBUG_LOG(@"LDClient stringVariation method called for feature=%@ and fallback=%@", featureKey, fallback);
-    if (![featureKey isKindOfClass:[NSString class]]) {
-        NSLog(@"featureKey should be an NSString. Returning fallback value");
+- (NSString*)stringVariation:(NSString *)flagKey fallback:(NSString*)fallback{
+    DEBUG_LOG(@"LDClient stringVariation method called for flagKey=%@ and fallback=%@", flagKey, fallback);
+    if (![flagKey isKindOfClass:[NSString class]]) {
+        NSLog(@"flagKey should be an NSString. Returning fallback value");
         return fallback;
     }
-    if (self.clientStarted) {
-        BOOL flagExists = [self.ldUser doesFlagExist: featureKey];
-        NSObject *flagValue = [self.ldUser flagValue: featureKey];
-        NSString *returnValue = fallback;
-        if ([flagValue isKindOfClass:[NSString class]] && flagExists) {
-            returnValue = (NSString *)flagValue;
-        }
-
-        [[LDDataManager sharedManager] createFeatureEvent: featureKey keyValue:returnValue defaultKeyValue:fallback user:self.ldUser config:self.ldConfig];
-        return returnValue;
-    } else {
+    if (!self.clientStarted) {
         DEBUG_LOGX(@"LDClient not started yet!");
+        return fallback;
     }
-    return fallback;
+
+    LDFlagConfigValue *flagConfigValue = [self.ldUser.flagConfig flagConfigValueForFlagKey:flagKey];
+    NSString *returnValue = flagConfigValue.value && [flagConfigValue.value isKindOfClass:[NSString class]] ? flagConfigValue.value : fallback;
+
+    [[LDDataManager sharedManager] createFlagEvaluationEventsWithFlagKey:flagKey
+                                                       reportedFlagValue:returnValue
+                                                         flagConfigValue:flagConfigValue
+                                                        defaultFlagValue:fallback
+                                                                    user:self.ldUser
+                                                                  config:self.ldConfig];
+    return returnValue;
 }
 
-- (NSArray*)arrayVariation:(NSString *)featureKey fallback:(NSArray*)fallback{
-    DEBUG_LOG(@"LDClient arrayVariation method called for feature=%@ and fallback=%@", featureKey, fallback);
-    if (![featureKey isKindOfClass:[NSString class]]) {
-        NSLog(@"featureKey should be an NSString. Returning fallback value");
+- (NSArray*)arrayVariation:(NSString *)flagKey fallback:(NSArray*)fallback{
+    DEBUG_LOG(@"LDClient arrayVariation method called for flagKey=%@ and fallback=%@", flagKey, fallback);
+    if (![flagKey isKindOfClass:[NSString class]]) {
+        NSLog(@"flagKey should be an NSString. Returning fallback value");
         return fallback;
     }
     if (!self.clientStarted) {
         DEBUG_LOGX(@"LDClient not started yet!");
         return fallback;
     }
-    BOOL flagExists = [self.ldUser doesFlagExist: featureKey];
-    id flagValue = [self.ldUser flagValue: featureKey];
-    NSArray *returnValue = fallback;
-    if (flagExists && [flagValue isKindOfClass:[NSArray class]]) {
-        returnValue = (NSArray *)flagValue;
-    }
-
-    [[LDDataManager sharedManager] createFeatureEvent: featureKey keyValue:returnValue defaultKeyValue:fallback user:self.ldUser config:self.ldConfig];
+
+    LDFlagConfigValue *flagConfigValue = [self.ldUser.flagConfig flagConfigValueForFlagKey:flagKey];
+    NSArray *returnValue = flagConfigValue.value && [flagConfigValue.value isKindOfClass:[NSArray class]] ? flagConfigValue.value : fallback;
+
+    [[LDDataManager sharedManager] createFlagEvaluationEventsWithFlagKey:flagKey
+                                                       reportedFlagValue:returnValue
+                                                         flagConfigValue:flagConfigValue
+                                                        defaultFlagValue:fallback
+                                                                    user:self.ldUser
+                                                                  config:self.ldConfig];
     return returnValue;
 }
 
-- (NSDictionary*)dictionaryVariation:(NSString *)featureKey fallback:(NSDictionary*)fallback{
-    DEBUG_LOG(@"LDClient dictionaryVariation method called for feature=%@ and fallback=%@", featureKey, fallback);
-    if (![featureKey isKindOfClass:[NSString class]]) {
-        NSLog(@"featureKey should be an NSString. Returning fallback value");
+- (NSDictionary*)dictionaryVariation:(NSString *)flagKey fallback:(NSDictionary*)fallback{
+    DEBUG_LOG(@"LDClient dictionaryVariation method called for flagKey=%@ and fallback=%@", flagKey, fallback);
+    if (![flagKey isKindOfClass:[NSString class]]) {
+        NSLog(@"flagKey should be an NSString. Returning fallback value");
         return fallback;
     }
     if (!self.clientStarted) {
         DEBUG_LOGX(@"LDClient not started yet!");
         return fallback;
     }
-    BOOL flagExists = [self.ldUser doesFlagExist: featureKey];
-    id flagValue = [self.ldUser flagValue: featureKey];
-    NSDictionary *returnValue = fallback;
-    if (flagExists && [flagValue isKindOfClass:[NSDictionary class]]) {
-        returnValue = (NSDictionary *)flagValue;
-    }
-
-    [[LDDataManager sharedManager] createFeatureEvent: featureKey keyValue:returnValue defaultKeyValue:fallback user:self.ldUser config:self.ldConfig];
+
+    LDFlagConfigValue *flagConfigValue = [self.ldUser.flagConfig flagConfigValueForFlagKey:flagKey];
+    NSDictionary *returnValue = flagConfigValue.value && [flagConfigValue.value isKindOfClass:[NSDictionary class]] ? flagConfigValue.value : fallback;
+
+    [[LDDataManager sharedManager] createFlagEvaluationEventsWithFlagKey:flagKey
+                                                       reportedFlagValue:returnValue
+                                                         flagConfigValue:flagConfigValue
+                                                        defaultFlagValue:fallback
+                                                                    user:self.ldUser
+                                                                  config:self.ldConfig];
     return returnValue;
 }
 
 - (BOOL)track:(NSString *)eventName data:(NSDictionary *)dataDictionary
 {
     DEBUG_LOG(@"LDClient track method called for event=%@ and data=%@", eventName, dataDictionary);
     if (self.clientStarted) {
-        [[LDDataManager sharedManager] createCustomEvent:eventName withCustomValuesDictionary: dataDictionary user:self.ldUser config:self.ldConfig];
+        [[LDDataManager sharedManager] createCustomEventWithKey:eventName customData: dataDictionary user:self.ldUser config:self.ldConfig];
         return YES;
     } else {
         DEBUG_LOGX(@"LDClient not started yet!");

Darkly/LDClientManager.h

@@ -27,7 +27,7 @@
 
 - (void)syncWithServerForEvents;
 - (void)syncWithServerForConfig;
-- (void)processedEvents:(BOOL)success jsonEventArray:(NSArray *)jsonEventArray;
+- (void)processedEvents:(BOOL)success jsonEventArray:(NSArray*)jsonEventArray responseDate:(NSDate*)responseDate;
 - (void)processedConfig:(BOOL)success jsonConfigDictionary:(NSDictionary *)jsonConfigDictionary;
 - (void)startPolling;
 - (void)stopPolling;