prepare 3.8.2 release (#78)

* initial move of code from js-client-sdk-private

* changelog note

* rm obsolete comment

* add npm audit helper

* update babel, jest, rollup

* fix rollup config

* fix ES build, dependency cleanup

* add Releaser metadata

* Update babel config to work in `test` without `useBuiltIns`

* copyedits

* fix misnamed directory

* use spread operator instead of Object.assign

* add issue templates

* add babel-eslint

* add event capacity config property

* re-add deprecation warning on samplingInterval

* better config validation

* remove rollup-plugins-node-resolve

* use newer Rollup node-resolve plugin

* rm rollup-plugin-includepaths (unused)

* npm audit fix (handlebars dependency from jest)

* comment

* copyedit

* use new test helpers + misc test cleanup

* clean up stream testing logic

* fix hash parameter

* linter

* clearer way to model the config option defaults/types

* test improvements

* change internal param name

* comment

* fix default logger logic

* simpler way to enforce minimum values

* implement diagnostic events in common JS package (#11)

* add support for function type in config options

* add support for function type in config options (#13)

* add wrapper metadata options and fix custom header logic

* lint

* lint

* remove image-loading logic from common code, replace it with an abstraction

* add validation for options.streaming

* typo

* rm unused params

* typo in comment

* misc fixes to merged code from external PR

* add event payload ID header

* npm audit fix

* change exact dependencies to best-compatible

* standardize linting

* disallow "window" and "document"

* improve diag event tests + debug logging

* misc cleanup

* fix updating secure mode hash with identify()

* don't omit streamInits.failed when it's false

* clean up init state logic, prevent unhandled rejections

* lint

* less strict matching of json content-type header

* remove unsafe usage of hasOwnProperty

* console logger must tolerate console object not always existing

* fix double initialization of diagnostics manager

* fix TypeScript declaration for track() and add more TS compilation tests (#27)

* remove startsWith usage (#28)

* prevent poll caused by a stream ping from overwriting later poll for another user (#29)

* upgrade jest dependency and transitive yargs-parser dependency (#30)

* Add null to LDEvaluationDetail.reason type (#31)

* Revert "Add null to LDEvaluationDetail.reason type (#31)"

This reverts commit bcb1573.

* Revert "Add null to LDEvaluationDetail.reason type (#31)"

This reverts commit bcb1573.

* nullable evaluation reason (#32)

* adding alias event functionality (#33)

* set stream read timeout

* Add prepare script (#34)

* add a missing typescript verification (#36)

* Removed the guides link

* Correct doc link (#36)

* Fix typo in LDClient.on jsdoc (#37)

* add inlineUsersInEvents option in TypeScript (#37)

* Filter private attributes on debug event users. Send variation for debug events.

* update uuid package version (#39)

* use Releaser v2 config + newer CI image

* First half, add the type, create the new options, add the new util method, and add tests

* Second half, call the tranform util method before calling any HTTP requests

* Update the transform to work on a copy of headers instead of mutating it

* add comments about removing custom event warning logic in the future

* revert updating of UUID dependency (#43)

* Revert "update uuid package version (#39)"

This reverts commit 3b2ff6c.

* update package-lock.json

* better error handling for local storage operations (#44)

* better error handling for local storage operations

* lint

* fix obsolete comments

* add basic logger similar to server-side Node SDK (#45)

* fix exports and add validation of custom logger (#46)

* remove typedoc.js file that interferes with Releaser's docs build

* update typescript version

* add maintenance branch

* backport sc-142333 fix

* make URL path concatenation work right whether base URL has a trailing slash or not (#61)

* make URL path concatenation work right whether base URL has a trailing slash or not

* lint

* Implement application tags for 3.x. (#62)

* don't include deleted flags in allFlags (#66)

* Backport changes to seen request cache. (#74)

* Backport changes for inspectors V2 and tag length enforcement. (#76)

* Fix onflags invocation. (#78)

* Implement jitter and backoff. (#79)

* Merge: Remove flatMap usage. (#83)

Co-authored-by: Mateusz Sikora <mateusz.sikora@ramp.network>

Co-authored-by: Eli Bishop <eli@launchdarkly.com>
Co-authored-by: Zach Davis <zach@launchdarkly.com>
Co-authored-by: LaunchDarklyCI <dev@launchdarkly.com>
Co-authored-by: Ben Woskow <bwoskow@launchdarkly.com>
Co-authored-by: Ben Woskow <48036130+bwoskow-ld@users.noreply.github.com>
Co-authored-by: Michael Siadak <mike.siadak@gmail.com>
Co-authored-by: Jeff Wen <sinchangwen@gmail.com>
Co-authored-by: Andrey Krasnov <34657799+Doesntmeananything@users.noreply.github.com>
Co-authored-by: Gavin Whelan <gwhelan@launchdarkly.com>
Co-authored-by: LaunchDarklyReleaseBot <launchdarklyreleasebot@launchdarkly.com>
Co-authored-by: Louis Chan <lchan@launchdarkly.com>
Co-authored-by: Louis Chan <91093020+louis-launchdarkly@users.noreply.github.com>
Co-authored-by: Ryan Lamb <4955475+kinyoklion@users.noreply.github.com>
Co-authored-by: Mateusz Sikora <mateusz.sikora@ramp.network>

Author: 13 people

src/Stream.js

@@ -1,6 +1,7 @@
 import * as messages from './messages';
 import { appendUrlPath, base64URLEncode, objectHasOwnProperty } from './utils';
 import { getLDHeaders, transformHeaders } from './headers';
+import { isHttpErrorRecoverable } from './errors';
 
 // The underlying event source implementation is abstracted via the platform object, which should
 // have these three properties:
@@ -16,6 +17,8 @@ import { getLDHeaders, transformHeaders } from './headers';
 // interval between heartbeats from the LaunchDarkly streaming server. If this amount of time elapses
 // with no new data, the connection will be cycled.
 const streamReadTimeoutMillis = 5 * 60 * 1000; // 5 minutes
+const maxRetryDelay = 30 * 1000; // Maximum retry delay 30 seconds.
+const jitterRatio = 0.5; // Delay should be 50%-100% of calculated time.
 
 export default function Stream(platform, config, environment, diagnosticsAccumulator) {
   const baseUrl = config.streamUrl;
@@ -24,7 +27,7 @@ export default function Stream(platform, config, environment, diagnosticsAccumul
   const evalUrlPrefix = appendUrlPath(baseUrl, '/eval/' + environment);
   const useReport = config.useReport;
   const withReasons = config.evaluationReasons;
-  const streamReconnectDelay = config.streamReconnectDelay;
+  const baseReconnectDelay = config.streamReconnectDelay;
   const headers = getLDHeaders(platform, config);
   let firstConnectionErrorLogged = false;
   let es = null;
@@ -33,6 +36,22 @@ export default function Stream(platform, config, environment, diagnosticsAccumul
   let user = null;
   let hash = null;
   let handlers = null;
+  let retryCount = 0;
+
+  function backoff() {
+    const delay = baseReconnectDelay * Math.pow(2, retryCount);
+    return delay > maxRetryDelay ? maxRetryDelay : delay;
+  }
+
+  function jitter(computedDelayMillis) {
+    return computedDelayMillis - Math.trunc(Math.random() * jitterRatio * computedDelayMillis);
+  }
+
+  function getNextRetryDelay() {
+    const delay = jitter(backoff());
+    retryCount += 1;
+    return delay;
+  }
 
   stream.connect = function(newUser, newHash, newHandlers) {
     user = newUser;
@@ -63,13 +82,31 @@ export default function Stream(platform, config, environment, diagnosticsAccumul
   };
 
   function handleError(err) {
+    // The event source may not produce a status. But the LaunchDarkly
+    // polyfill can. If we can get the status, then we should stop retrying
+    // on certain error codes.
+    if (err.status && typeof err.status === 'number' && !isHttpErrorRecoverable(err.status)) {
+      // If we encounter an unrecoverable condition, then we do not want to
+      // retry anymore.
+      closeConnection();
+      logger.error(messages.unrecoverableStreamError(err));
+      // Ensure any pending retry attempts are not done.
+      if (reconnectTimeoutReference) {
+        clearTimeout(reconnectTimeoutReference);
+        reconnectTimeoutReference = null;
+      }
+      return;
+    }
+
+    const delay = getNextRetryDelay();
+
     if (!firstConnectionErrorLogged) {
-      logger.warn(messages.streamError(err, streamReconnectDelay));
+      logger.warn(messages.streamError(err, delay));
       firstConnectionErrorLogged = true;
     }
     logConnectionResult(false);
     closeConnection();
-    tryConnect(streamReconnectDelay);
+    tryConnect(delay);
   }
 
   function tryConnect(delay) {
@@ -123,6 +160,11 @@ export default function Stream(platform, config, environment, diagnosticsAccumul
       }
 
       es.onerror = handleError;
+
+      es.onopen = () => {
+        // If the connection is a success, then reset the retryCount.
+        retryCount = 0;
+      };
     }
   }
 

src/__tests__/Stream-test.js

@@ -170,6 +170,7 @@ describe('Stream', () => {
     const nAttempts = 5;
     for (let i = 0; i < nAttempts; i++) {
       es.mockError('test error');
+      await sleepAsync(10);
       const created1 = await platform.testing.expectStream();
       const es1 = created1.eventSource;
 
@@ -185,6 +186,40 @@ describe('Stream', () => {
     }
   });
 
+  it.each([401, 403])('does not reconnect after an unrecoverable error', async status => {
+    const config = { ...defaultConfig, streamReconnectDelay: 1, useReport: false };
+    const stream = new Stream(platform, config, envName);
+    stream.connect(user);
+
+    const created = await platform.testing.expectStream();
+    const es = created.eventSource;
+
+    expect(es.readyState).toBe(EventSource.CONNECTING);
+    es.mockOpen();
+    expect(es.readyState).toBe(EventSource.OPEN);
+
+    es.mockError({ status });
+    await sleepAsync(10);
+    expect(platform.testing.eventSourcesCreated.length()).toEqual(0);
+  });
+
+  it.each([400, 408, 429])('does reconnect after a recoverable error', async status => {
+    const config = { ...defaultConfig, streamReconnectDelay: 1, useReport: false };
+    const stream = new Stream(platform, config, envName);
+    stream.connect(user);
+
+    const created = await platform.testing.expectStream();
+    const es = created.eventSource;
+
+    expect(es.readyState).toBe(EventSource.CONNECTING);
+    es.mockOpen();
+    expect(es.readyState).toBe(EventSource.OPEN);
+
+    es.mockError({ status });
+    await sleepAsync(10);
+    expect(platform.testing.eventSourcesCreated.length()).toEqual(1);
+  });
+
   it('logs a warning for only the first failed connection attempt', async () => {
     const config = { ...defaultConfig, streamReconnectDelay: 1 };
     const stream = new Stream(platform, config, envName);
@@ -197,6 +232,7 @@ describe('Stream', () => {
     const nAttempts = 5;
     for (let i = 0; i < nAttempts; i++) {
       es.mockError('test error');
+      await sleepAsync(10);
       const created1 = await platform.testing.expectStream();
       es = created1.eventSource;
       es.mockOpen();
@@ -221,6 +257,7 @@ describe('Stream', () => {
     const nAttempts = 5;
     for (let i = 0; i < nAttempts; i++) {
       es.mockError('test error #1');
+      await sleepAsync(10);
       const created1 = await platform.testing.expectStream();
       es = created1.eventSource;
       es.mockOpen();
@@ -232,15 +269,16 @@ describe('Stream', () => {
 
     for (let i = 0; i < nAttempts; i++) {
       es.mockError('test error #2');
+      await sleepAsync(10);
       const created1 = await platform.testing.expectStream();
       es = created1.eventSource;
       es.mockOpen();
     }
 
     // make sure there is just a single logged message rather than five (one per attempt)
     expect(logger.output.warn).toEqual([
-      messages.streamError('test error #1', 1),
-      messages.streamError('test error #2', 1),
+      expect.stringContaining('test error #1'),
+      expect.stringContaining('test error #2'),
     ]);
   });
 

src/headers.js

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

src/messages.js

@@ -123,12 +123,16 @@ export const streamError = function(err, streamReconnectDelay) {
   return (
     'Error on stream connection: ' +
     errorString(err) +
-    ', will continue retrying every ' +
+    ', will continue retrying after ' +
     streamReconnectDelay +
     ' milliseconds.'
   );
 };
 
+export const unrecoverableStreamError = function(err) {
+  return `Error on stream connection ${errorString(err)}, giving up permanently`;
+};
+
 export const unknownOption = name => 'Ignoring unknown config option "' + name + '"';
 
 export const wrongOptionType = (name, expectedType, actualType) =>