launchdarkly-js-sdk-common 5.1.0 → 5.3.0

package/src/__tests__/LDClient-timeout-test.js

@@ -0,0 +1,90 @@
+jest.mock('../InitializationState', () => jest.fn());
+
+import { initialize } from '../index';
+import InitializationState from '../InitializationState';
+import * as stubPlatform from './stubPlatform';
+
+const createHangingPromise = () =>
+  new Promise(() => {
+    // never resolves
+  });
+
+describe('timeout', () => {
+  let ldc;
+  let mockGetInitializationPromise;
+  let mockGetReadyPromise;
+  let logger;
+
+  beforeEach(() => {
+    mockGetInitializationPromise = jest.fn();
+    mockGetReadyPromise = jest.fn();
+    logger = stubPlatform.logger();
+    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: logger,
+      },
+      {}
+    ));
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it('waitForInitialization times out if initialization does not resolve', async () => {
+    const p = ldc.waitForInitialization(1);
+    await expect(p).rejects.toThrow(/timed out/);
+
+    // No warnings in this configuration.
+    expect(logger.output.warn).toEqual([]);
+    expect(logger.output.error).toEqual([
+      'waitForInitialization error: LaunchDarklyTimeoutError: waitForInitialization timed out after 1 seconds.',
+    ]);
+  });
+
+  it('waitForInitialization warns if no timeout is provided', async () => {
+    ldc.waitForInitialization();
+
+    expect(logger.output.warn).toEqual([
+      'The waitForInitialization function was called without a timeout specified. In a future version a default timeout will be applied.',
+    ]);
+  });
+
+  it('waitForInitialization warns if timeout is not a number', async () => {
+    ldc.waitForInitialization('10');
+
+    // You get two warnings in this case. Which should be fine as you have to go our of your way to get into this situation.
+    expect(logger.output.warn).toEqual([
+      'The waitForInitialization method was provided with a non-numeric timeout.',
+      'The waitForInitialization function was called without a timeout specified. In a future version a default timeout will be applied.',
+    ]);
+  });
+
+  it('waitForInitialization warns if timeout provided is too high', async () => {
+    ldc.waitForInitialization(10);
+
+    expect(logger.output.warn).toEqual([
+      'The waitForInitialization function was called with a timeout greater than 5 seconds. We recommend a timeout of 5 seconds or less.',
+    ]);
+  });
+
+  it('waitForInitialization does not timeout if the initialization promise resolves in the timeout', async () => {
+    mockGetInitializationPromise.mockImplementation(() => Promise.resolve('success'));
+
+    const p = ldc.waitForInitialization(5);
+
+    await expect(p).resolves.toEqual('success');
+
+    // No warnings in this configuration.
+    expect(logger.output.warn).toEqual([]);
+  });
+});

package/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);
       });

package/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,
 };

package/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(' ');

package/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 highTimeoutThreshold = 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
@@ -457,8 +462,8 @@ function initialize(env, context, specifiedOptions, platform, extraOptionDefs) {
           } else {
             mods[data.key] = { current: newDetail };
           }
-          handleFlagChanges(mods); // don't wait for this Promise to be resolved
           notifyInspectionFlagChanged(data, newFlag);
+          handleFlagChanges(mods); // don't wait for this Promise to be resolved
         } else {
           logger.debug(messages.debugStreamPatchIgnored(data.key));
         }
@@ -772,8 +777,42 @@ function initialize(env, context, specifiedOptions, platform, extraOptionDefs) {
     return flags;
   }
 
+  function waitForInitializationWithTimeout(timeout) {
+    if (timeout > highTimeoutThreshold) {
+      logger.warn(
+        'The waitForInitialization function was called with a timeout greater than ' +
+          `${highTimeoutThreshold} seconds. We recommend a timeout of ` +
+          `${highTimeoutThreshold} seconds or less.`
+      );
+    }
+
+    const initPromise = initializationStateTracker.getInitializationPromise();
+    const timeoutPromise = timedPromise(timeout, 'waitForInitialization');
+
+    return Promise.race([timeoutPromise, initPromise]).catch(e => {
+      if (e instanceof errors.LDTimeoutError) {
+        logger.error(`waitForInitialization error: ${e}`);
+      }
+      throw e;
+    });
+  }
+
+  function waitForInitialization(timeout = undefined) {
+    if (timeout !== undefined && timeout !== null) {
+      if (typeof timeout === 'number') {
+        return waitForInitializationWithTimeout(timeout);
+      }
+      logger.warn('The waitForInitialization method was provided with a non-numeric timeout.');
+    }
+    logger.warn(
+      'The waitForInitialization function was called without a timeout specified.' +
+        ' In a future version a default timeout will be applied.'
+    );
+    return initializationStateTracker.getInitializationPromise();
+  }
+
   const client = {
-    waitForInitialization: () => initializationStateTracker.getInitializationPromise(),
+    waitForInitialization,
     waitUntilReady: () => initializationStateTracker.getReadyPromise(),
     identify: identify,
     getContext: getContext,

package/src/messages.js

@@ -15,7 +15,7 @@ const clientInitialized = function() {
 };
 
 const docLink =
-  ' Please see https://docs.launchdarkly.com/sdk/client-side/javascript#initializing-the-client for instructions on SDK initialization.';
+  ' Please see https://docs.launchdarkly.com/sdk/client-side/javascript#initialize-the-client for instructions on SDK initialization.';
 
 const clientNotReady = function() {
   return 'LaunchDarkly client is not ready';
@@ -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,

package/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;

package/test-types.ts

@@ -54,7 +54,7 @@ var allBaseOptions: ld.LDOptionsBase = {
 var client: ld.LDClientBase = {} as ld.LDClientBase;  // wouldn't do this in real life, it's just so the following statements will compile
 
 client.waitUntilReady().then(() => {});
-client.waitForInitialization().then(() => {});
+client.waitForInitialization(5).then(() => {});
 
 client.identify(user).then(() => {});
 client.identify(user, undefined, () => {});

package/typedoc.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://typedoc.org/schema.json",
+  "name": "launchdarkly-js-sdk-common",
+  "includeVersion": true,
+  "entryPoints": [
+      "typings.d.ts",
+  ]
+}