launchdarkly-js-sdk-common 5.0.3 → 5.2.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/__tests__/stubPlatform.js

@@ -13,8 +13,6 @@ import { MockHttpState } from './mockHttp';
 // httpRequest?: (method, url, headers, body, sync) => requestProperties
 //   requestProperties.promise: Promise     // resolves to { status, header: (name) => value, body } or rejects for a network error
 //   requestProperties.cancel?: () => void  // provided if it's possible to cancel requests in this implementation
-// httpAllowsPost: boolean        // true if we can do cross-origin POST requests
-// httpFallbackPing?: (url) => {} // method for doing an HTTP GET without awaiting the result (i.e. browser image mechanism)
 // getCurrentUrl: () => string    // returns null if we're not in a browser
 // isDoNotTrack: () => boolean
 // localStorage: {
@@ -45,8 +43,6 @@ export function defaults() {
     httpRequest: mockHttpState.doRequest,
     diagnosticSdkData: { name: 'stub-sdk' },
     diagnosticPlatformData: { name: 'stub-platform' },
-    httpAllowsPost: () => true,
-    httpAllowsSync: () => true,
     getCurrentUrl: () => currentUrl,
     isDoNotTrack: () => doNotTrack,
     eventSourceFactory: (url, options) => {

package/src/__tests__/testUtils.js

@@ -62,7 +62,7 @@ export function MockEventSender() {
     calls,
     sendEvents: (events, url) => {
       calls.add({ events, url });
-      return Promise.resolve([{ serverTime, status }]);
+      return Promise.resolve({ serverTime, status });
     },
     setServerTime: time => {
       serverTime = time;

package/src/__tests__/utils-test.js

@@ -1,4 +1,4 @@
-import { appendUrlPath, base64URLEncode, chunkEventsForUrl, getLDUserAgentString, wrapPromiseCallback } from '../utils';
+import { appendUrlPath, getLDUserAgentString, wrapPromiseCallback } from '../utils';
 
 import * as stubPlatform from './stubPlatform';
 
@@ -63,15 +63,4 @@ describe('utils', () => {
       expect(ua).toEqual('stubClient/7.8.9');
     });
   });
-
-  describe('chunkEventsForUrl', () => {
-    it('should properly chunk the list of events', () => {
-      const context = { key: 'foo', kind: 'user' };
-      const event = { kind: 'identify', key: context.key };
-      const eventLength = base64URLEncode(JSON.stringify(event)).length;
-      const events = [event, event, event, event, event];
-      const chunks = chunkEventsForUrl(eventLength * 2, events);
-      expect(chunks).toEqual([[event, event], [event, event], [event]]);
-    });
-  });
 });

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
@@ -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

@@ -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/src/utils.js

@@ -112,46 +112,6 @@ function transformVersionedValuesToValues(flagsState) {
   return ret;
 }
 
-/**
- * Returns an array of event groups each of which can be safely URL-encoded
- * without hitting the safe maximum URL length of certain browsers.
- *
- * @param {number} maxLength maximum URL length targeted
- * @param {Array[Object}]} events queue of events to divide
- * @returns Array[Array[Object]]
- */
-function chunkEventsForUrl(maxLength, events) {
-  const allEvents = events.slice(0);
-  const allChunks = [];
-  let remainingSpace = maxLength;
-  let chunk;
-
-  while (allEvents.length > 0) {
-    chunk = [];
-
-    while (remainingSpace > 0) {
-      const event = allEvents.shift();
-      if (!event) {
-        break;
-      }
-      remainingSpace = remainingSpace - base64URLEncode(JSON.stringify(event)).length;
-      // If we are over the max size, put this one back on the queue
-      // to try in the next round, unless this event alone is larger
-      // than the limit, in which case, screw it, and try it anyway.
-      if (remainingSpace < 0 && chunk.length > 0) {
-        allEvents.unshift(event);
-      } else {
-        chunk.push(event);
-      }
-    }
-
-    remainingSpace = maxLength;
-    allChunks.push(chunk);
-  }
-
-  return allChunks;
-}
-
 function getLDUserAgentString(platform) {
   const version = platform.version || '?';
   return platform.userAgent + '/' + version;
@@ -188,7 +148,6 @@ module.exports = {
   appendUrlPath,
   base64URLEncode,
   btoa,
-  chunkEventsForUrl,
   clone,
   deepEquals,
   extend,

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, () => {});