prepare 3.1.0 release (#5)

Author: LaunchDarklyCI

package-lock.json

@@ -7,7 +7,7 @@ import * as utils from './utils';
 
 export default function EventProcessor(platform, options, environmentId, emitter = null, sender = null) {
   const processor = {};
-  const eventSender = sender || EventSender(platform, options.eventsUrl, environmentId);
+  const eventSender = sender || EventSender(platform, options.eventsUrl, environmentId, options);
   const summarizer = EventSummarizer();
   const userFilter = UserFilter(options);
   const inlineUsers = options.inlineUsersInEvents;

src/EventProcessor.js

@@ -3,16 +3,12 @@ import * as utils from './utils';
 
 const MAX_URL_LENGTH = 2000;
 
-export default function EventSender(platform, eventsUrl, environmentId, imageCreator) {
+export default function EventSender(platform, eventsUrl, environmentId, options) {
   const postUrl = eventsUrl + '/events/bulk/' + environmentId;
   const imageUrl = eventsUrl + '/a/' + environmentId + '.gif';
+  const httpFallbackPing = platform.httpFallbackPing; // this will be set for us if we're in the browser SDK
   const sender = {};
 
-  function loadUrlUsingImage(src) {
-    const img = new window.Image();
-    img.src = src;
-  }
-
   function getResponseInfo(result) {
     const ret = { status: result.status };
     const dateStr = result.header('date');
@@ -26,7 +22,6 @@ export default function EventSender(platform, eventsUrl, environmentId, imageCre
   }
 
   function sendChunk(events, usePost) {
-    const createImage = imageCreator || loadUrlUsingImage;
     const jsonBody = JSON.stringify(events);
 
     function doPostRequest(canRetry) {
@@ -35,7 +30,7 @@ export default function EventSender(platform, eventsUrl, environmentId, imageCre
           'Content-Type': 'application/json',
           'X-LaunchDarkly-Event-Schema': '3',
         },
-        utils.getLDHeaders(platform)
+        utils.getLDHeaders(platform, options)
       );
       return platform
         .httpRequest('POST', postUrl, headers, jsonBody)
@@ -61,11 +56,8 @@ export default function EventSender(platform, eventsUrl, environmentId, imageCre
     if (usePost) {
       return doPostRequest(true).catch(() => {});
     } else {
-      const src = imageUrl + '?d=' + utils.base64URLEncode(jsonBody);
-      createImage(src);
-      return Promise.resolve();
-      // We do not specify an onload handler for the image because we don't want the client to wait around
-      // for the image to load - it won't provide a server response, there's nothing to be done.
+      httpFallbackPing && httpFallbackPing(imageUrl + '?d=' + utils.base64URLEncode(jsonBody));
+      return Promise.resolve(); // we don't wait for this request to complete, it's just a one-way ping
     }
   }
 

src/EventSender.js

@@ -17,7 +17,6 @@ export default function Requestor(platform, options, environment) {
   const baseUrl = options.baseUrl;
   const useReport = options.useReport;
   const withReasons = options.evaluationReasons;
-  const sendLDHeaders = options.sendLDHeaders;
   const logger = options.logger;
 
   const requestor = {};
@@ -32,7 +31,7 @@ export default function Requestor(platform, options, environment) {
     }
 
     const method = body ? 'REPORT' : 'GET';
-    const headers = sendLDHeaders ? utils.getLDHeaders(platform) : {};
+    const headers = utils.getLDHeaders(platform, options);
     if (body) {
       headers['Content-Type'] = 'application/json';
     }

src/Requestor.js

@@ -1,5 +1,5 @@
 import * as messages from './messages';
-import { base64URLEncode } from './utils';
+import { base64URLEncode, getLDHeaders } from './utils';
 
 // The underlying event source implementation is abstracted via the platform object, which should
 // have these three properties:
@@ -18,6 +18,7 @@ export default function Stream(platform, config, environment, hash) {
   const useReport = config.useReport;
   const withReasons = config.evaluationReasons;
   const streamReconnectDelay = config.streamReconnectDelay;
+  const headers = getLDHeaders(platform, config);
   let firstConnectionErrorLogged = false;
   let es = null;
   let reconnectTimeoutReference = null;
@@ -73,7 +74,7 @@ export default function Stream(platform, config, environment, hash) {
     reconnectTimeoutReference = null;
     let url;
     let query = '';
-    const options = {};
+    const options = { headers };
     if (platform.eventSourceFactory) {
       if (hash !== null && hash !== undefined) {
         query = 'h=' + hash;
@@ -82,7 +83,7 @@ export default function Stream(platform, config, environment, hash) {
         if (platform.eventSourceAllowsReport) {
           url = evalUrlPrefix;
           options.method = 'REPORT';
-          options.headers = { 'Content-Type': 'application/json' };
+          options.headers['Content-Type'] = 'application/json';
           options.body = JSON.stringify(user);
         } else {
           // if we can't do REPORT, fall back to the old ping-based stream

src/Stream.js

@@ -14,12 +14,10 @@ import * as stubPlatform from './stubPlatform';
 
 describe('EventSender', () => {
   let platform;
-  let platformWithoutCors;
   const envId = 'env';
 
   beforeEach(() => {
     platform = stubPlatform.defaults();
-    platformWithoutCors = { ...platform, httpAllowsPost: () => false };
   });
 
   function fakeImageCreator() {
@@ -53,7 +51,8 @@ describe('EventSender', () => {
     it('should encode events in a single chunk if they fit', async () => {
       const server = platform.testing.http.newServer();
       const imageCreator = fakeImageCreator();
-      const sender = EventSender(platformWithoutCors, server.url, envId, imageCreator);
+      const platformWithoutCors = { ...platform, httpAllowsPost: () => false, httpFallbackPing: imageCreator };
+      const sender = EventSender(platformWithoutCors, server.url, envId);
       const event1 = { kind: 'identify', key: 'userKey1' };
       const event2 = { kind: 'identify', key: 'userKey2' };
       const events = [event1, event2];
@@ -70,7 +69,8 @@ describe('EventSender', () => {
     it('should send events in multiple chunks if necessary', async () => {
       const server = platform.testing.http.newServer();
       const imageCreator = fakeImageCreator();
-      const sender = EventSender(platformWithoutCors, server.url, envId, imageCreator);
+      const platformWithoutCors = { ...platform, httpAllowsPost: () => false, httpFallbackPing: imageCreator };
+      const sender = EventSender(platformWithoutCors, server.url, envId);
       const events = [];
       for (let i = 0; i < 80; i++) {
         events.push({ kind: 'identify', key: 'thisIsALongUserKey' + i });
@@ -106,14 +106,29 @@ describe('EventSender', () => {
     });
 
     it('should send custom user-agent header', async () => {
+      const options = { sendLDHeaders: true };
       const server = platform.testing.http.newServer();
       server.byDefault(respond(202));
-      const sender = EventSender(platform, server.url, envId);
+      const sender = EventSender(platform, server.url, envId, options);
       const event = { kind: 'identify', key: 'userKey' };
       await sender.sendEvents([event], false);
 
       const r = await server.nextRequest();
       expect(r.headers['x-launchdarkly-user-agent']).toEqual(utils.getLDUserAgentString(platform));
+      expect(r.headers['x-launchdarkly-wrapper']).toBeUndefined();
+    });
+
+    it('should send wrapper info if present', async () => {
+      const options = { sendLDHeaders: true, wrapperName: 'FakeSDK' };
+      const server = platform.testing.http.newServer();
+      server.byDefault(respond(202));
+      const sender = EventSender(platform, server.url, envId, options);
+      const event = { kind: 'identify', key: 'userKey' };
+      await sender.sendEvents([event], server.url);
+
+      const r = await server.nextRequest();
+      expect(r.headers['x-launchdarkly-user-agent']).toEqual(utils.getLDUserAgentString(platform));
+      expect(r.headers['x-launchdarkly-wrapper']).toEqual('FakeSDK');
     });
 
     const retryableStatuses = [400, 408, 429, 500, 503];

src/__tests__/EventSender-test.js

@@ -4,7 +4,7 @@ import * as messages from '../messages';
 import * as utils from '../utils';
 
 import semverCompare from 'semver-compare';
-import { eventSink, promisifySingle, sleepAsync, withCloseable } from 'launchdarkly-js-test-helpers';
+import { eventSink, promisifySingle, sleepAsync, withCloseable, AsyncQueue } from 'launchdarkly-js-test-helpers';
 
 import { respond, respondJson } from './mockHttp';
 import * as stubPlatform from './stubPlatform';
@@ -453,20 +453,30 @@ describe('LDClient', () => {
 
   describe('identify', () => {
     it('does not set user until the flag config has been updated', async () => {
-      function sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-      }
-
-      const user2 = { key: 'user2' };
-      const client = platform.testing.makeClient(envName, user);
-      await client.waitForInitialization();
-      server.autoRespond = false;
-      const identifyPromise = client.identify(user2);
-      await sleep(200); // sleep to jump some async ticks.
-      expect(client.getUser()).toEqual(user);
-      server.respond();
-      await identifyPromise;
-      expect(client.getUser()).toEqual(user2);
+      await withServers(async (baseConfig, pollServer) => {
+        pollServer.byDefault(respondJson({}));
+        await withClient(user, baseConfig, async client => {
+          const signal = new AsyncQueue();
+          const user2 = { key: 'user2' };
+          await client.waitForInitialization();
+
+          // Make the server wait until signaled to return the next response
+          pollServer.byDefault((req, res) => {
+            signal.take().then(() => {
+              respondJson({})(req, res);
+            });
+          });
+
+          const identifyPromise = client.identify(user2);
+          await sleepAsync(100); // sleep to jump some async ticks
+          expect(client.getUser()).toEqual(user);
+
+          signal.add();
+          await identifyPromise;
+
+          expect(client.getUser()).toEqual(user2);
+        });
+      });
     });
 
     it('updates flag values when the user changes', async () => {

src/__tests__/LDClient-test.js

@@ -159,37 +159,71 @@ describe('Requestor', () => {
 
   it('sends custom user-agent header in GET mode when sendLDHeaders is true', async () => {
     await withServer(async (baseConfig, server) => {
-      const requestor = Requestor(platform, { ...baseConfig, sendLDHeaders: true }, env);
+      const config = { ...baseConfig, sendLDHeaders: true };
+      const requestor = Requestor(platform, config, env);
 
       await requestor.fetchFlagSettings(user);
 
       expect(server.requests.length()).toEqual(1);
       const req = await server.requests.take();
       expect(req.headers['x-launchdarkly-user-agent']).toEqual(utils.getLDUserAgentString(platform));
+      expect(req.headers['x-launchdarkly-wrapper']).toBeUndefined();
+    });
+  });
+
+  it('sends wrapper info if specified in GET mode when sendLDHeaders is true', async () => {
+    await withServer(async (baseConfig, server) => {
+      const config = { ...baseConfig, sendLDHeaders: true, wrapperName: 'FakeSDK' };
+      const requestor = Requestor(platform, config, env);
+
+      await requestor.fetchFlagSettings(user);
+
+      expect(server.requests.length()).toEqual(1);
+      const req = await server.requests.take();
+      expect(req.headers['x-launchdarkly-user-agent']).toEqual(utils.getLDUserAgentString(platform));
+      expect(req.headers['x-launchdarkly-wrapper']).toEqual('FakeSDK');
     });
   });
 
   it('sends custom user-agent header in REPORT mode when sendLDHeaders is true', async () => {
     await withServer(async (baseConfig, server) => {
-      const requestor = Requestor(platform, { ...baseConfig, useReport: true, sendLDHeaders: true }, env);
+      const config = { ...baseConfig, useReport: true, sendLDHeaders: true };
+      const requestor = Requestor(platform, config, env);
+
+      await requestor.fetchFlagSettings(user, 'hash1');
+
+      expect(server.requests.length()).toEqual(1);
+      const req = await server.requests.take();
+      expect(req.headers['x-launchdarkly-user-agent']).toEqual(utils.getLDUserAgentString(platform));
+      expect(req.headers['x-launchdarkly-wrapper']).toBeUndefined();
+    });
+  });
+
+  it('sends wrapper info if specified in REPORT mode when sendLDHeaders is true', async () => {
+    await withServer(async (baseConfig, server) => {
+      const config = { ...baseConfig, useReport: true, sendLDHeaders: true, wrapperName: 'FakeSDK' };
+      const requestor = Requestor(platform, config, env);
 
       await requestor.fetchFlagSettings(user, 'hash1');
 
       expect(server.requests.length()).toEqual(1);
       const req = await server.requests.take();
       expect(req.headers['x-launchdarkly-user-agent']).toEqual(utils.getLDUserAgentString(platform));
+      expect(req.headers['x-launchdarkly-wrapper']).toEqual('FakeSDK');
     });
   });
 
   it('does NOT send custom user-agent header when sendLDHeaders is false', async () => {
     await withServer(async (baseConfig, server) => {
-      const requestor = Requestor(platform, { ...baseConfig, sendLDHeaders: false }, env);
+      const config = { ...baseConfig, sendLDHeaders: false };
+      const requestor = Requestor(platform, config, env);
 
       await requestor.fetchFlagSettings(user);
 
       expect(server.requests.length()).toEqual(1);
       const req = await server.requests.take();
       expect(req.headers['x-launchdarkly-user-agent']).toBeUndefined();
+      expect(req.headers['x-launchdarkly-wrapper']).toBeUndefined();
     });
   });