prepare 5.2.0 release

package.json

@@ -38,10 +38,10 @@
     "eslint-formatter-pretty": "^1.3.0",
     "eslint-plugin-babel": "^5.0.0",
     "eslint-plugin-prettier": "^2.6.0",
-    "jest": "^25.5.4",
+    "jest": "^26.6.3",
     "jsdom": "^11.11.0",
     "launchdarkly-js-test-helpers": "1.1.0",
-    "prettier": "1.11.1",
+    "prettier": "1.19.1",
     "readline-sync": "^1.4.9",
     "typescript": "~4.4.4"
   },

src/ContextFilter.js

@@ -118,8 +118,8 @@ function ContextFilter(config) {
       filtered._meta = filtered._meta || {};
       // If any private attributes started with '/' we need to convert them to references, otherwise the '/' will
       // cause the literal to incorrectly be treated as a reference.
-      filtered._meta.privateAttributes = user.privateAttributeNames.map(
-        literal => (literal.startsWith('/') ? AttributeReference.literalToReference(literal) : literal)
+      filtered._meta.privateAttributes = user.privateAttributeNames.map(literal =>
+        literal.startsWith('/') ? AttributeReference.literalToReference(literal) : literal
       );
     }
 

src/__tests__/EventProcessor-test.js

@@ -10,7 +10,10 @@ import { MockEventSender } from './testUtils';
 // tests; here, we use a mock EventSender.
 
 describe.each([
-  [{ key: 'userKey', name: 'Red' }, { key: 'userKey', kind: 'user', _meta: { redactedAttributes: ['/name'] } }],
+  [
+    { key: 'userKey', name: 'Red' },
+    { key: 'userKey', kind: 'user', _meta: { redactedAttributes: ['/name'] } },
+  ],
   [
     { kind: 'user', key: 'userKey', name: 'Red' },
     { key: 'userKey', kind: 'user', _meta: { redactedAttributes: ['/name'] } },

src/__tests__/EventSummarizer-test.js

@@ -99,7 +99,10 @@ describe('EventSummarizer', () => {
       key1: {
         contextKinds: ['user'],
         default: 111,
-        counters: [{ variation: 0, value: 100, version: 11, count: 1 }, { value: 111, version: 11, count: 2 }],
+        counters: [
+          { variation: 0, value: 100, version: 11, count: 1 },
+          { value: 111, version: 11, count: 2 },
+        ],
       },
     };
     expect(data.features).toEqual(expectedFeatures);

src/__tests__/LDClient-events-test.js

@@ -487,6 +487,18 @@ describe('LDClient events', () => {
     });
   });
 
+  it('does warn when a metric value is non-numeric', async () => {
+    await withClientAndEventProcessor(user, {}, async client => {
+      await client.waitForInitialization();
+
+      client.track('known', undefined, '12');
+      expect(platform.testing.logger.output.warn).toEqual([
+        'The track function was called with a non-numeric "metricValue" (string), ' +
+          'only numeric metric values are supported.',
+      ]);
+    });
+  });
+
   it('emits an error when tracking a non-string custom event', async () => {
     await withClientAndEventProcessor(user, {}, async client => {
       await client.waitForInitialization();

src/__tests__/LDClient-timeout-test.js

@@ -0,0 +1,67 @@
+jest.mock('../InitializationState', () => jest.fn());
+jest.mock('../timedPromise', () => jest.fn());
+
+import { initialize } from '../index';
+import InitializationState from '../InitializationState';
+import timedPromise from '../timedPromise';
+import * as stubPlatform from './stubPlatform';
+
+const createHangingPromise = () =>
+  new Promise(() => {
+    // never resolves
+  });
+
+describe('timeout', () => {
+  let ldc;
+  let mockGetInitializationPromise;
+  let mockGetReadyPromise;
+
+  beforeEach(() => {
+    mockGetInitializationPromise = jest.fn();
+    mockGetReadyPromise = jest.fn();
+    timedPromise.mockImplementation(() => Promise.reject(new Error('timed out')));
+    InitializationState.mockImplementation(() => ({
+      getInitializationPromise: mockGetInitializationPromise,
+      getReadyPromise: mockGetReadyPromise,
+      signalFailure: jest.fn(),
+    }));
+    mockGetInitializationPromise.mockImplementation(createHangingPromise);
+    mockGetReadyPromise.mockImplementation(createHangingPromise);
+    ({ client: ldc } = initialize(
+      'abc',
+      { kind: 'user', key: 'test-user' },
+      {
+        logger: stubPlatform.logger(),
+      },
+      {}
+    ));
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it('waitForInitialization timeout', async () => {
+    const p = ldc.waitForInitialization();
+    await expect(p).rejects.toThrow(/timed out/);
+  });
+
+  it('waitForInitialization succeeds', async () => {
+    timedPromise.mockImplementation(createHangingPromise);
+    mockGetInitializationPromise.mockImplementation(() => Promise.resolve('success'));
+
+    const p = ldc.waitForInitialization();
+
+    await expect(p).resolves.toEqual('success');
+  });
+
+  it('waitForInitialization succeeds with custom timeout', async () => {
+    timedPromise.mockImplementation(createHangingPromise);
+    mockGetInitializationPromise.mockImplementation(() => Promise.resolve('success'));
+
+    const p = ldc.waitForInitialization(10);
+
+    await expect(p).resolves.toEqual('success');
+    expect(timedPromise).toBeCalledWith(10, 'waitForInitialization');
+  });
+});

src/__tests__/diagnosticEvents-test.js

@@ -117,7 +117,10 @@ describe('DiagnosticsManager', () => {
   const expectedStatsForPeriodicEvent1 = {
     droppedEvents: 1,
     eventsInLastBatch: 2,
-    streamInits: [{ timestamp: 1001, durationMillis: 100 }, { timestamp: 1002, failed: true, durationMillis: 500 }],
+    streamInits: [
+      { timestamp: 1001, durationMillis: 100 },
+      { timestamp: 1002, failed: true, durationMillis: 500 },
+    ],
   };
   const expectedStatsForPeriodicEvent2 = {
     droppedEvents: 0,
@@ -392,7 +395,10 @@ describe('DiagnosticsManager', () => {
           dataSinceDate: storedStats.dataSinceDate,
           droppedEvents: 2,
           eventsInLastBatch: 3,
-          streamInits: [{ timestamp: 1000, durationMillis: 500 }, { timestamp: 1001, durationMillis: 501 }],
+          streamInits: [
+            { timestamp: 1000, durationMillis: 500 },
+            { timestamp: 1001, durationMillis: 501 },
+          ],
         });
         expect(firstEvent.creationDate).toBeGreaterThanOrEqual(timeBeforeStart);
       });

src/errors.js

@@ -19,6 +19,7 @@ const LDInvalidEventKeyError = createCustomError('LaunchDarklyInvalidEventKeyErr
 const LDInvalidArgumentError = createCustomError('LaunchDarklyInvalidArgumentError');
 const LDFlagFetchError = createCustomError('LaunchDarklyFlagFetchError');
 const LDInvalidDataError = createCustomError('LaunchDarklyInvalidDataError');
+const LDTimeoutError = createCustomError('LaunchDarklyTimeoutError');
 
 function isHttpErrorRecoverable(status) {
   if (status >= 400 && status < 500) {
@@ -35,5 +36,6 @@ module.exports = {
   LDInvalidArgumentError,
   LDInvalidDataError,
   LDFlagFetchError,
+  LDTimeoutError,
   isHttpErrorRecoverable,
 };

src/headers.js

@@ -17,8 +17,8 @@ function getLDHeaders(platform, options) {
   if (tagKeys.length) {
     h['x-launchdarkly-tags'] = tagKeys
       .sort()
-      .map(
-        key => (Array.isArray(tags[key]) ? tags[key].sort().map(value => `${key}/${value}`) : [`${key}/${tags[key]}`])
+      .map(key =>
+        Array.isArray(tags[key]) ? tags[key].sort().map(value => `${key}/${value}`) : [`${key}/${tags[key]}`]
       )
       .reduce((flattened, item) => flattened.concat(item), [])
       .join(' ');

src/index.js

@@ -16,9 +16,11 @@ const errors = require('./errors');
 const messages = require('./messages');
 const { checkContext, getContextKeys } = require('./context');
 const { InspectorTypes, InspectorManager } = require('./InspectorManager');
+const timedPromise = require('./timedPromise');
 
 const changeEvent = 'change';
 const internalChangeEvent = 'internal-change';
+const waitTimeout = 5;
 
 // This is called by the per-platform initialize functions to create the base client object that we
 // may also extend with additional behavior. It returns an object with these properties:
@@ -365,6 +367,9 @@ function initialize(env, context, specifiedOptions, platform, extraOptionDefs) {
       emitter.maybeReportError(new errors.LDInvalidEventKeyError(messages.unknownCustomEventKey(key)));
       return;
     }
+    if (metricValue !== undefined && typeof metricValue !== 'number') {
+      logger.warn(messages.invalidMetricValue(typeof metricValue));
+    }
 
     // The following logic was used only for the JS browser SDK (js-client-sdk) and
     // is no longer needed as of version 2.9.13 of that SDK. The other client-side
@@ -772,8 +777,20 @@ function initialize(env, context, specifiedOptions, platform, extraOptionDefs) {
     return flags;
   }
 
+  function waitForInitialization(timeout = waitTimeout) {
+    const slow = initializationStateTracker.getInitializationPromise();
+    const timed = timedPromise(timeout, 'waitForInitialization');
+
+    return Promise.race([timed, slow]).catch(e => {
+      if (e.message.includes('timed out')) {
+        logger.error(`waitForInitialization error: ${e}`);
+      }
+      throw e;
+    });
+  }
+
   const client = {
-    waitForInitialization: () => initializationStateTracker.getInitializationPromise(),
+    waitForInitialization,
     waitUntilReady: () => initializationStateTracker.getReadyPromise(),
     identify: identify,
     getContext: getContext,

src/messages.js

@@ -190,6 +190,9 @@ const invalidTagValue = name => `Config option "${name}" must only contain lette
 
 const tagValueTooLong = name => `Value of "${name}" was longer than 64 characters and was discarded.`;
 
+const invalidMetricValue = badType =>
+  `The track function was called with a non-numeric "metricValue" (${badType}), only numeric metric values are supported.`;
+
 module.exports = {
   bootstrapInvalid,
   bootstrapOldFormat,
@@ -219,6 +222,7 @@ module.exports = {
   invalidData,
   invalidInspector,
   invalidKey,
+  invalidMetricValue,
   invalidContext,
   invalidTagValue,
   localStorageUnavailable,

src/timedPromise.js

@@ -0,0 +1,17 @@
+const { LDTimeoutError } = require('./errors');
+
+/**
+ * Returns a promise which errors after t seconds.
+ *
+ * @param t Timeout in seconds.
+ * @param taskName Name of task being timed for logging and error reporting.
+ */
+function timedPromise(t, taskName) {
+  return new Promise((_res, reject) => {
+    setTimeout(() => {
+      const e = `${taskName} timed out after ${t} seconds.`;
+      reject(new LDTimeoutError(e));
+    }, t * 1000);
+  });
+}
+module.exports = timedPromise;