prepare 2.5.0 release (#110)

Author: eli-darkly

CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to the LaunchDarkly client-side JavaScript SDK will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org).
 
+## [2.5.0] - 2018-08-27
+### Changed:
+- Starting in version 2.0.0, there was a problem where analytics events would not be generated correctly if you initialized the client with bootstrap data, because the bootstrap data did not include some flag metadata that the front end uses for events. The client now supports an extended format for bootstrap data that fixes this problem; this is generated by calling a new method that has been added to the server-side SDKs, `allFlagsState`/`all_flags_state` (previously `allFlags`/`all_flags`). Therefore, if you want analytics event data and you are using bootstrap data from the back end, you should upgrade both your JavaScript SDK and your server-side SDK, and use `allFlagsState` on the back end. This does not require any changes in your JavaScript code. If you use bootstrap data in the old format, the SDK will still be usable but events will not work correctly.
+- When posting events to LaunchDarkly, if a request fails, it will be retried once.
+- The TypeScript mappings for the SDK were omitted from the distribution in the previous release. They are now in the distribution again, in the root folder instead of in `src`, and have been renamed from `index.d.ts` to `typings.d.ts`.
+
 ## [2.4.1] - 2018-08-14
 ### Fixed:
 - The result value of `identify()` (provided by either a promise or a callback, once the flag values for the new user have been retrieved) used to be a simple map of flag keys to values, until it was accidentally changed to an internal data structure in version 2.0.0. It is now a map of flag keys to values again, consistent with what is returned by `allFlags()`.

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "ldclient-js",
-  "version": "2.4.1",
+  "version": "2.5.0",
   "description": "LaunchDarkly SDK for JavaScript",
   "author": "LaunchDarkly <team@launchdarkly.com>",
   "license": "Apache-2.0",
@@ -15,8 +15,10 @@
     "ldclient.es.js",
     "ldclient.es.js.map",
     "ldclient.min.js",
-    "ldclient.min.js.map"
+    "ldclient.min.js.map",
+    "typings.d.ts"
   ],
+  "types": "./typings.d.ts",
   "main": "dist/ldclient.cjs.js",
   "module": "dist/ldclient.es.js",
   "scripts": {
@@ -36,7 +38,6 @@
     "clean": "rimraf dist/**",
     "prepublishOnly": "npm run build:min"
   },
-  "types": "./src/index.d.ts",
   "devDependencies": {
     "babel-core": "6.26.0",
     "babel-eslint": "8.2.2",

package.json

@@ -1,3 +1,4 @@
+import * as errors from './errors';
 import * as utils from './utils';
 
 const MAX_URL_LENGTH = 2000;
@@ -30,23 +31,34 @@ export default function EventSender(eventsUrl, environmentId, forceHasCors, imag
 
   function sendChunk(events, usePost, sync) {
     const createImage = imageCreator || loadUrlUsingImage;
+    const jsonBody = JSON.stringify(events);
     const send = onDone => {
-      if (usePost) {
+      function createRequest(canRetry) {
         const xhr = new XMLHttpRequest();
         xhr.open('POST', postUrl, !sync);
         utils.addLDHeaders(xhr);
         xhr.setRequestHeader('Content-Type', 'application/json');
         xhr.setRequestHeader('X-LaunchDarkly-Event-Schema', '3');
-
         if (!sync) {
           xhr.addEventListener('load', () => {
-            onDone(getResponseInfo(xhr));
+            if (xhr.status >= 400 && errors.isHttpErrorRecoverable(xhr.status) && canRetry) {
+              createRequest(false).send(jsonBody);
+            } else {
+              onDone(getResponseInfo(xhr));
+            }
           });
+          if (canRetry) {
+            xhr.addEventListener('error', () => {
+              createRequest(false).send(jsonBody);
+            });
+          }
         }
-
-        xhr.send(JSON.stringify(events));
+        return xhr;
+      }
+      if (usePost) {
+        createRequest(true).send(jsonBody);
       } else {
-        const src = imageUrl + '?d=' + utils.base64URLEncode(JSON.stringify(events));
+        const src = imageUrl + '?d=' + utils.base64URLEncode(jsonBody);
         createImage(src, sync ? null : onDone);
       }
     };

src/EventSender.js

@@ -103,8 +103,10 @@ describe('EventSender', () => {
       const sender = EventSender(eventsUrl, envId, true);
       const event = { kind: 'identify', key: 'userKey' };
       sender.sendEvents([event], false);
-      lastRequest().respond();
-      expect(lastRequest().async).toEqual(true);
+      requests[0].respond();
+      expect(requests.length).toEqual(1);
+      expect(requests[0].async).toEqual(true);
+      expect(JSON.parse(requests[0].requestBody)).toEqual([event]);
     });
 
     it('should send synchronously', () => {
@@ -132,9 +134,49 @@ describe('EventSender', () => {
     it('should send custom user-agent header', () => {
       const sender = EventSender(eventsUrl, envId, true);
       const event = { kind: 'identify', key: 'userKey' };
-      sender.sendEvents([event], true);
+      sender.sendEvents([event], false);
       lastRequest().respond();
       expect(lastRequest().requestHeaders['X-LaunchDarkly-User-Agent']).toEqual(utils.getLDUserAgentString());
     });
+
+    const retryableStatuses = [400, 408, 429, 500, 503];
+    for (const i in retryableStatuses) {
+      const status = retryableStatuses[i];
+      it('should retry on error ' + status, () => {
+        const sender = EventSender(eventsUrl, envId, true);
+        const event = { kind: 'false', key: 'userKey' };
+        sender.sendEvents([event], false);
+        requests[0].respond(status);
+        expect(requests.length).toEqual(2);
+        expect(JSON.parse(requests[1].requestBody)).toEqual([event]);
+      });
+    }
+
+    it('should not retry more than once', () => {
+      const sender = EventSender(eventsUrl, envId, true);
+      const event = { kind: 'false', key: 'userKey' };
+      sender.sendEvents([event], false);
+      requests[0].respond(503);
+      expect(requests.length).toEqual(2);
+      requests[1].respond(503);
+      expect(requests.length).toEqual(2);
+    });
+
+    it('should not retry on error 401', () => {
+      const sender = EventSender(eventsUrl, envId, true);
+      const event = { kind: 'false', key: 'userKey' };
+      sender.sendEvents([event], false);
+      requests[0].respond(401);
+      expect(requests.length).toEqual(1);
+    });
+
+    it('should retry on I/O error', () => {
+      const sender = EventSender(eventsUrl, envId, true);
+      const event = { kind: 'false', key: 'userKey' };
+      sender.sendEvents([event], false);
+      requests[0].error();
+      expect(requests.length).toEqual(2);
+      expect(JSON.parse(requests[1].requestBody)).toEqual([event]);
+    });
   });
 });

src/__tests__/EventSender-test.js

@@ -158,7 +158,7 @@ describe('LDClient', () => {
       requests[0].respond(404);
     });
 
-    it('should not fetch flag settings since bootstrap is provided', () => {
+    it('should not fetch flag settings if bootstrap is provided', () => {
       LDClient.initialize(envName, user, {
         bootstrap: {},
       });
@@ -167,6 +167,38 @@ describe('LDClient', () => {
       expect(/sdk\/eval/.test(settingsRequest.url)).toEqual(false);
     });
 
+    it('sets flag values from bootstrap object with old format', () => {
+      const client = LDClient.initialize(envName, user, {
+        bootstrap: { foo: 'bar' },
+      });
+
+      expect(client.variation('foo')).toEqual('bar');
+    });
+
+    it('logs warning when bootstrap object uses old format', () => {
+      LDClient.initialize(envName, user, {
+        bootstrap: { foo: 'bar' },
+      });
+
+      expect(warnSpy).toHaveBeenCalledWith(messages.bootstrapOldFormat());
+    });
+
+    it('sets flag values from bootstrap object with new format', () => {
+      const client = LDClient.initialize(envName, user, {
+        bootstrap: { foo: 'bar', $flagsState: { foo: { version: 1 } } },
+      });
+
+      expect(client.variation('foo')).toEqual('bar');
+    });
+
+    it('does not log warning when bootstrap object uses new format', () => {
+      LDClient.initialize(envName, user, {
+        bootstrap: { foo: 'bar', $flagsState: { foo: { version: 1 } } },
+      });
+
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+
     it('should contain package version', () => {
       // Arrange
       const version = LDClient.version;
@@ -420,13 +452,15 @@ describe('LDClient', () => {
       expect(e.user).toEqual(user);
     }
 
-    function expectFeatureEvent(e, key, value, variation, version, defaultVal) {
+    function expectFeatureEvent(e, key, value, variation, version, defaultVal, trackEvents, debugEventsUntilDate) {
       expect(e.kind).toEqual('feature');
       expect(e.key).toEqual(key);
       expect(e.value).toEqual(value);
       expect(e.variation).toEqual(variation);
       expect(e.version).toEqual(version);
       expect(e.default).toEqual(defaultVal);
+      expect(e.trackEvents).toEqual(trackEvents);
+      expect(e.debugEventsUntilDate).toEqual(debugEventsUntilDate);
     }
 
     it('sends an identify event at startup', done => {
@@ -513,6 +547,32 @@ describe('LDClient', () => {
 
       server.respond();
     });
+
+    it('can get metadata for events from bootstrap object', done => {
+      const ep = stubEventProcessor();
+      const bootstrapData = {
+        foo: 'bar',
+        $flagsState: {
+          foo: {
+            variation: 1,
+            version: 2,
+            trackEvents: true,
+            debugEventsUntilDate: 1000,
+          },
+        },
+      };
+      const client = LDClient.initialize(envName, user, { eventProcessor: ep, bootstrap: bootstrapData });
+
+      client.on('ready', () => {
+        client.variation('foo', 'x');
+
+        expect(ep.events.length).toEqual(2);
+        expectIdentifyEvent(ep.events[0], user);
+        expectFeatureEvent(ep.events[1], 'foo', 'bar', 1, 2, 'x', true, 1000);
+
+        done();
+      });
+    });
   });
 
   describe('event listening', () => {

src/__tests__/LDClient-test.js

@@ -21,7 +21,7 @@ export const LDFlagFetchError = createCustomError('LaunchDarklyFlagFetchError');
 
 export function isHttpErrorRecoverable(status) {
   if (status >= 400 && status < 500) {
-    return status === 408 || status === 429;
+    return status === 400 || status === 408 || status === 429;
   }
   return true;
 }

src/errors.js

@@ -28,13 +28,42 @@ export function initialize(env, user, options = {}) {
   const events = options.eventProcessor || EventProcessor(eventsUrl, environment, options, emitter);
   const requestor = Requestor(baseUrl, environment, options.useReport);
   const seenRequests = {};
-  let flags = typeof options.bootstrap === 'object' ? utils.transformValuesToVersionedValues(options.bootstrap) : {};
+  let flags = typeof options.bootstrap === 'object' ? readFlagsFromBootstrap(options.bootstrap) : {};
   let goalTracker;
   let useLocalStorage;
   let goals;
   let subscribedToChangeEvents;
   let firstEvent = true;
 
+  function readFlagsFromBootstrap(data) {
+    // If the bootstrap data came from an older server-side SDK, we'll have just a map of keys to values.
+    // Newer SDKs that have an allFlagsState method will provide an extra "$flagsState" key that contains
+    // the rest of the metadata we want. We do it this way for backward compatibility with older JS SDKs.
+    const keys = Object.keys(data);
+    const metadataKey = '$flagsState';
+    const validKey = '$valid';
+    const metadata = data[metadataKey];
+    if (!metadata && keys.length) {
+      console.warn(messages.bootstrapOldFormat());
+    }
+    if (data[validKey] === false) {
+      console.warn(messages.bootstrapInvalid());
+    }
+    const ret = {};
+    keys.forEach(key => {
+      if (key !== metadataKey && key !== validKey) {
+        let flag = { value: data[key] };
+        if (metadata && metadata[key]) {
+          flag = utils.extend(flag, metadata[key]);
+        } else {
+          flag.version = 0;
+        }
+        ret[key] = flag;
+      }
+    });
+    return ret;
+  }
+
   function shouldEnqueueEvent() {
     return sendEvents && !doNotTrack();
   }

src/index.js

@@ -37,6 +37,18 @@ export const invalidUser = function() {
   return 'Invalid user specified.' + docLink;
 };
 
+export const bootstrapOldFormat = function() {
+  return (
+    'LaunchDarkly client was initialized with bootstrap data that did not include flag metadata. ' +
+    'Events may not be sent correctly.' +
+    docLink
+  );
+};
+
+export const bootstrapInvalid = function() {
+  return 'LaunchDarkly bootstrap data is not available because the back end could not read the flags.';
+};
+
 export const deprecated = function(oldName, newName) {
   return '[LaunchDarkly] "' + oldName + '" is deprecated, please use "' + newName + '"';
 };