prepare 6.2.3 release (#234)

Author: LaunchDarklyReleaseBot

evaluator.js

@@ -5,7 +5,7 @@ const util = require('util');
 const stringifyAttrs = require('./utils/stringifyAttrs');
 const { safeAsyncEachSeries } = require('./utils/asyncUtils');
 
-const builtins = ['key', 'ip', 'country', 'email', 'firstName', 'lastName', 'avatar', 'name', 'anonymous'];
+const builtins = ['key', 'secondary', 'ip', 'country', 'email', 'firstName', 'lastName', 'avatar', 'name', 'anonymous'];
 const userAttrsToStringifyForEvaluation = ['key', 'secondary'];
 // Currently we are not stringifying the rest of the built-in attributes prior to evaluation, only for events.
 // This is because it could affect evaluation results for existing users (ch35206).

event_factory.js

@@ -1,28 +1,28 @@
-function EventFactory(withReasons) {
-  const ef = {};
-
-  function isExperiment(flag, reason) {
-    if (reason) {
-      // If the reason says we're in an experiment, we are. Otherwise, apply
-      // the legacy rule exclusion logic.
-      if (reason.inExperiment) {
-        return true;
-      }
-      switch (reason.kind) {
-        case 'RULE_MATCH': {
-          const index = reason.ruleIndex;
-          if (index !== undefined) {
-            const rules = flag.rules || [];
-            return index >= 0 && index < rules.length && !!rules[index].trackEvents;
-          }
-          break;
+function isExperiment(flag, reason) {
+  if (reason) {
+    // If the reason says we're in an experiment, we are. Otherwise, apply
+    // the legacy rule exclusion logic.
+    if (reason.inExperiment) {
+      return true;
+    }
+    switch (reason.kind) {
+      case 'RULE_MATCH': {
+        const index = reason.ruleIndex;
+        if (index !== undefined) {
+          const rules = flag.rules || [];
+          return index >= 0 && index < rules.length && !!rules[index].trackEvents;
         }
-        case 'FALLTHROUGH':
-          return !!flag.trackEventsFallthrough;
+        break;
       }
+      case 'FALLTHROUGH':
+        return !!flag.trackEventsFallthrough;
     }
-    return false;
   }
+  return false;
+}
+
+function EventFactory(withReasons) {
+  const ef = {};
 
   ef.newEvalEvent = (flag, user, detail, defaultVal, prereqOfFlag) => {
     const addExperimentData = isExperiment(flag, detail.reason);
@@ -128,4 +128,7 @@ function EventFactory(withReasons) {
   return ef;
 }
 
-module.exports = EventFactory;
+module.exports = {
+  EventFactory,
+  isExperiment,
+};

flags_state.js

@@ -1,23 +1,31 @@
-function FlagsStateBuilder(valid) {
+function FlagsStateBuilder(valid, withReasons) {
   const builder = {};
   const flagValues = {};
   const flagMetadata = {};
 
-  builder.addFlag = (flag, value, variation, reason, detailsOnlyIfTracked) => {
+  builder.addFlag = (flag, value, variation, reason, trackEvents, trackReason, detailsOnlyIfTracked) => {
     flagValues[flag.key] = value;
     const meta = {};
-    if (!detailsOnlyIfTracked || flag.trackEvents || flag.debugEventsUntilDate) {
-      meta.version = flag.version;
-      if (reason) {
-        meta.reason = reason;
-      }
-    }
     if (variation !== undefined && variation !== null) {
       meta.variation = variation;
     }
-    if (flag.trackEvents) {
+    const omitDetails =
+      detailsOnlyIfTracked &&
+      !trackEvents &&
+      !trackReason &&
+      (flag.debugEventsUntilDate === undefined || flag.debugEventsUntilDate === null);
+    if (!omitDetails) {
+      meta.version = flag.version;
+    }
+    if (reason && (trackReason || (withReasons && !omitDetails))) {
+      meta.reason = reason;
+    }
+    if (trackEvents) {
       meta.trackEvents = true;
     }
+    if (trackReason) {
+      meta.trackReason = true;
+    }
     if (flag.debugEventsUntilDate !== undefined && flag.debugEventsUntilDate !== null) {
       meta.debugEventsUntilDate = flag.debugEventsUntilDate;
     }

index.js

@@ -4,7 +4,7 @@ const FeatureStoreEventWrapper = require('./feature_store_event_wrapper');
 const FileDataSource = require('./file_data_source');
 const Requestor = require('./requestor');
 const EventEmitter = require('events').EventEmitter;
-const EventFactory = require('./event_factory');
+const { EventFactory, isExperiment } = require('./event_factory');
 const EventProcessor = require('./event_processor');
 const PollingProcessor = require('./polling');
 const StreamingProcessor = require('./streaming');
@@ -298,50 +298,71 @@ const newClient = function (sdkKey, originalConfig) {
       options = options || {};
     }
     return wrapPromiseCallback(
-      new Promise((resolve, reject) => {
+      (async () => {
         if (client.isOffline()) {
           config.logger.info('allFlagsState() called in offline mode. Returning empty state.');
-          return resolve(FlagsStateBuilder(false).build());
+          return FlagsStateBuilder(false).build();
         }
 
         if (!user) {
           config.logger.info('allFlagsState() called without user. Returning empty state.');
-          return resolve(FlagsStateBuilder(false).build());
+          return FlagsStateBuilder(false).build();
+        }
+
+        let valid = true;
+
+        if (!initComplete) {
+          const inited = await new Promise(resolve => config.featureStore.initialized(resolve));
+          if (inited) {
+            config.logger.warn(
+              'Called allFlagsState before client initialization; using last known values from data store'
+            );
+          } else {
+            config.logger.warn(
+              'Called allFlagsState before client initialization. Data store not available; returning empty state'
+            );
+            valid = false;
+          }
         }
 
-        const builder = FlagsStateBuilder(true);
+        const builder = FlagsStateBuilder(valid, options.withReasons);
         const clientOnly = options.clientSideOnly;
-        const withReasons = options.withReasons;
         const detailsOnlyIfTracked = options.detailsOnlyForTrackedFlags;
-        config.featureStore.all(dataKind.features, flags => {
-          safeAsyncEach(
-            flags,
-            (flag, iterateeCb) => {
-              if (clientOnly && !flag.clientSide) {
-                iterateeCb();
-              } else {
-                // At the moment, we don't send any events here
-                evaluator.evaluate(flag, user, eventFactoryDefault, (err, detail) => {
-                  if (err !== null) {
-                    maybeReportError(
-                      new Error('Error for feature flag "' + flag.key + '" while evaluating all flags: ' + err)
-                    );
-                  }
-                  builder.addFlag(
-                    flag,
-                    detail.value,
-                    detail.variationIndex,
-                    withReasons ? detail.reason : null,
-                    detailsOnlyIfTracked
-                  );
+
+        return await new Promise((resolve, reject) =>
+          config.featureStore.all(dataKind.features, flags => {
+            safeAsyncEach(
+              flags,
+              (flag, iterateeCb) => {
+                if (clientOnly && !flag.clientSide) {
                   iterateeCb();
-                });
-              }
-            },
-            err => (err ? reject(err) : resolve(builder.build()))
-          );
-        });
-      }),
+                } else {
+                  // At the moment, we don't send any events here
+                  evaluator.evaluate(flag, user, eventFactoryDefault, (err, detail) => {
+                    if (err !== null) {
+                      maybeReportError(
+                        new Error('Error for feature flag "' + flag.key + '" while evaluating all flags: ' + err)
+                      );
+                    }
+                    const requireExperimentData = isExperiment(flag, detail.reason);
+                    builder.addFlag(
+                      flag,
+                      detail.value,
+                      detail.variationIndex,
+                      detail.reason,
+                      flag.trackEvents || requireExperimentData,
+                      requireExperimentData,
+                      detailsOnlyIfTracked
+                    );
+                    iterateeCb();
+                  });
+                }
+              },
+              err => (err ? reject(err) : resolve(builder.build()))
+            );
+          })
+        );
+      })(),
       callback
     );
   };

operators.js

@@ -44,6 +44,9 @@ function semVerOperator(fn) {
 }
 
 function parseSemVer(input) {
+  if (typeof input !== 'string') {
+    return null;
+  }
   if (input.startsWith('v')) {
     // the semver library tolerates a leading "v", but the standard does not.
     return null;