launchdarkly-js-sdk-common 4.0.1 → 4.1.0

package/.eslintrc.yaml

@@ -11,7 +11,6 @@ plugins:
   - babel
   - prettier
 globals:
-  VERSION: true
   describe: true
   it: true
   expect: true

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to the `launchdarkly-js-sdk-common` package will be documented in this file. Changes that affect the dependent SDKs such as `launchdarkly-js-client-sdk` should also be logged in those projects, in the next release that uses the updated version of this package. This project adheres to [Semantic Versioning](http://semver.org).
 
+## [4.0.3] - 2022-02-16
+### Fixed:
+- If the SDK receives invalid JSON data from a streaming connection (possibly as a result of the connection being cut off), it now uses its regular error-handling logic: the error is emitted as an `error` event or, if there are no `error` event listeners, it is logged. Previously, it would be thrown as an unhandled exception.
+
+## [4.0.2] - 2022-01-25
+### Removed:
+- Removed the `version` export which was originally a constant inserted by the Rollup build, but was no longer usable since Rollup is no longer being used. The SDKs never used this export, since they have `version` properties of their own; the version string of `launchdarkly-js-sdk-common` was never meant to be exposed to applications.
+
 ## [4.0.1] - 2022-01-21
 ### Changed:
 - This package is now published as a regular Node module. Previously, it was published as minified bundles created by Rollup. There was no need for this since Rollup is only needed for web code, and the `js-client-sdk` build already runs Rollup to embed the `js-sdk-common` code. Using Rollup caused the platform-dependent behavior of `uuid` to fail because the code for only one platform (browser or Node) was embedded.
@@ -15,6 +23,10 @@ All notable changes to the `launchdarkly-js-sdk-common` package will be document
 - Removed the type `NonNullableLDEvaluationReason`, which was a side effect of the `LDEvaluationDetail.reason` being incorrectly defined before.
 - Removed all types, properties, and functions that were deprecated as of the last 3.x release.
 
+## [3.5.1] - 2022-02-17
+### Fixed:
+- If the SDK receives invalid JSON data from a streaming connection (possibly as a result of the connection being cut off), it now uses its regular error-handling logic: the error is emitted as an `error` event or, if there are no `error` event listeners, it is logged. Previously, it would be thrown as an unhandled exception.
+
 ## [3.5.0] - 2022-01-14
 ### Added:
 - New configurable logger factory `commonBasicLogger` and `BasicLoggerOptions`. The `commonBasicLogger` method is not intended to be exported directly in the SDKs, but wrapped to provide platform-specific behavior.

package/docs/typedoc.js

@@ -4,7 +4,7 @@ module.exports = {
     '**/node_modules/**',
     'test-types.ts'
   ],
-  name: "LaunchDarkly Javascript SDK Core Components (4.0.1)",
+  name: "LaunchDarkly Javascript SDK Core Components (4.0.2)",
   readme: 'none',                // don't add a home page with a copy of README.md
   entryPoints: "/tmp/project-releaser/project/typings.d.ts",
   entryPointStrategy: "expand"

package/jest.config.js

@@ -9,7 +9,4 @@ module.exports = {
   transform: {
     '^.+\\.js$': 'babel-jest',
   },
-  globals: {
-    VERSION: version,
-  },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "launchdarkly-js-sdk-common",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "description": "LaunchDarkly SDK for JavaScript - common code",
   "author": "LaunchDarkly <team@launchdarkly.com>",
   "license": "Apache-2.0",
@@ -40,8 +40,6 @@
     "launchdarkly-js-test-helpers": "1.1.0",
     "prettier": "1.11.1",
     "readline-sync": "^1.4.9",
-    "semver": "^5.5.0",
-    "semver-compare": "^1.0.0",
     "typescript": "~4.4.4"
   },
   "dependencies": {

package/src/EventProcessor.js

@@ -15,7 +15,7 @@ function EventProcessor(
 ) {
   const processor = {};
   const eventSender = sender || EventSender(platform, environmentId, options);
-  const mainEventsUrl = options.eventsUrl + '/events/bulk/' + environmentId;
+  const mainEventsUrl = utils.appendUrlPath(options.eventsUrl, '/events/bulk/' + environmentId);
   const summarizer = EventSummarizer();
   const userFilter = UserFilter(options);
   const inlineUsers = options.inlineUsersInEvents;

package/src/EventSender.js

@@ -1,12 +1,13 @@
 const errors = require('./errors');
 const utils = require('./utils');
 const { v1: uuidv1 } = require('uuid');
+const { getLDHeaders, transformHeaders } = require('./headers');
 
 const MAX_URL_LENGTH = 2000;
 
 function EventSender(platform, environmentId, options) {
   const imageUrlPath = '/a/' + environmentId + '.gif';
-  const baseHeaders = utils.extend({ 'Content-Type': 'application/json' }, utils.getLDHeaders(platform, options));
+  const baseHeaders = utils.extend({ 'Content-Type': 'application/json' }, getLDHeaders(platform, options));
   const httpFallbackPing = platform.httpFallbackPing; // this will be set for us if we're in the browser SDK
   const sender = {};
 
@@ -34,7 +35,7 @@ function EventSender(platform, environmentId, options) {
             'X-LaunchDarkly-Payload-ID': payloadId,
           });
       return platform
-        .httpRequest('POST', url, utils.transformHeaders(headers, options), jsonBody)
+        .httpRequest('POST', url, transformHeaders(headers, options), jsonBody)
         .promise.then(result => {
           if (!result) {
             // This was a response from a fire-and-forget request, so we won't have a status.

package/src/Requestor.js

@@ -2,6 +2,7 @@ const utils = require('./utils');
 const errors = require('./errors');
 const messages = require('./messages');
 const promiseCoalescer = require('./promiseCoalescer');
+const { transformHeaders, getLDHeaders } = require('./headers');
 
 const jsonContentType = 'application/json';
 
@@ -31,7 +32,7 @@ function Requestor(platform, options, environment) {
     }
 
     const method = body ? 'REPORT' : 'GET';
-    const headers = utils.getLDHeaders(platform, options);
+    const headers = getLDHeaders(platform, options);
     if (body) {
       headers['Content-Type'] = jsonContentType;
     }
@@ -45,7 +46,7 @@ function Requestor(platform, options, environment) {
       activeRequests[endpoint] = coalescer;
     }
 
-    const req = platform.httpRequest(method, endpoint, utils.transformHeaders(headers, options), body);
+    const req = platform.httpRequest(method, endpoint, transformHeaders(headers, options), body);
     const p = req.promise.then(
       result => {
         if (result.status === 200) {
@@ -75,7 +76,7 @@ function Requestor(platform, options, environment) {
   // Performs a GET request to an arbitrary path under baseUrl. Returns a Promise which will resolve
   // with the parsed JSON response, or will be rejected if the request failed.
   requestor.fetchJSON = function(path) {
-    return fetchJSON(baseUrl + path, null);
+    return fetchJSON(utils.appendUrlPath(baseUrl, path), null);
   };
 
   // Requests the current state of all flags for the given user from LaunchDarkly. Returns a Promise

package/src/Stream.js

@@ -1,5 +1,6 @@
 const messages = require('./messages');
-const { base64URLEncode, getLDHeaders, transformHeaders, objectHasOwnProperty } = require('./utils');
+const { appendUrlPath, base64URLEncode, objectHasOwnProperty } = require('./utils');
+const { getLDHeaders, transformHeaders } = require('./headers');
 
 // The underlying event source implementation is abstracted via the platform object, which should
 // have these three properties:
@@ -20,7 +21,7 @@ function Stream(platform, config, environment, diagnosticsAccumulator) {
   const baseUrl = config.streamUrl;
   const logger = config.logger;
   const stream = {};
-  const evalUrlPrefix = baseUrl + '/eval/' + environment;
+  const evalUrlPrefix = appendUrlPath(baseUrl, '/eval/' + environment);
   const useReport = config.useReport;
   const withReasons = config.evaluationReasons;
   const streamReconnectDelay = config.streamReconnectDelay;
@@ -98,7 +99,7 @@ function Stream(platform, config, environment, diagnosticsAccumulator) {
           options.body = JSON.stringify(user);
         } else {
           // if we can't do REPORT, fall back to the old ping-based stream
-          url = baseUrl + '/ping/' + environment;
+          url = appendUrlPath(baseUrl, '/ping/' + environment);
           query = '';
         }
       } else {

package/src/__tests__/.eslintrc.yaml

@@ -1,6 +1,5 @@
 ---
 globals:
-  VERSION: true
   sinon: true
   expect: true
   requestor: true

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

@@ -1,3 +1,4 @@
+import * as messages from '../messages';
 import * as utils from '../utils';
 
 import { AsyncQueue, eventSink, sleepAsync, withCloseable } from 'launchdarkly-js-test-helpers';
@@ -650,6 +651,38 @@ describe('LDClient streaming', () => {
       });
     });
 
+    describe('emits error if malformed JSON is received', () => {
+      const doMalformedJsonEventTest = async (eventName, eventData) => {
+        // First, verify that there isn't an unhandled rejection if we're not listening for an error
+        await withClientAndServer({}, async client => {
+          await client.waitForInitialization();
+          client.setStreaming(true);
+
+          const stream = await expectStreamConnecting(fullStreamUrlWithUser);
+          stream.eventSource.mockEmit(eventName, { data: eventData });
+        });
+
+        // Then, repeat the test using a listener to observe the error event
+        await withClientAndServer({}, async client => {
+          const errorEvents = new AsyncQueue();
+          client.on('error', e => errorEvents.add(e));
+
+          await client.waitForInitialization();
+          client.setStreaming(true);
+
+          const stream = await expectStreamConnecting(fullStreamUrlWithUser);
+          stream.eventSource.mockEmit(eventName, { data: eventData });
+
+          const e = await errorEvents.take();
+          expect(e.message).toEqual(messages.invalidData());
+        });
+      };
+
+      it('in put event', async () => doMalformedJsonEventTest('put', '{no'));
+      it('in patch event', async () => doMalformedJsonEventTest('patch', '{no'));
+      it('in delete event', async () => doMalformedJsonEventTest('delete', '{no'));
+    });
+
     it('reconnects to stream if the user changes', async () => {
       const user2 = { key: 'user2' };
       const encodedUser2 = 'eyJrZXkiOiJ1c2VyMiJ9';

package/src/__tests__/LDClient-test.js

@@ -2,7 +2,6 @@ import * as LDClient from '../index';
 import * as messages from '../messages';
 import * as utils from '../utils';
 
-import semverCompare from 'semver-compare';
 import { eventSink, promisifySingle, sleepAsync, withCloseable, AsyncQueue } from 'launchdarkly-js-test-helpers';
 
 import { respond, respondJson } from './mockHttp';
@@ -106,13 +105,6 @@ describe('LDClient', () => {
       });
     });
 
-    it('should contain package version', () => {
-      const version = LDClient.version;
-      // All client bundles above 1.0.7 should contain package version
-      const result = semverCompare(version, '1.0.6');
-      expect(result).toEqual(1);
-    });
-
     async function verifyCustomHeader(sendLDHeaders, shouldGetHeaders) {
       await withServers(async (baseConfig, pollServer) => {
         await withClient(user, { ...baseConfig, sendLDHeaders }, async client => {

package/src/__tests__/Stream-test.js

@@ -1,7 +1,7 @@
 import { DiagnosticsAccumulator } from '../diagnosticEvents';
 import * as messages from '../messages';
 import Stream from '../Stream';
-import { getLDHeaders } from '../utils';
+import { getLDHeaders } from '../headers';
 
 import { sleepAsync } from 'launchdarkly-js-test-helpers';
 import EventSource from './EventSource-mock';

package/src/__tests__/configuration-test.js

@@ -214,4 +214,43 @@ describe('configuration', () => {
     expect(config.extraFunctionOption).toBe(fn);
     await listener.expectError(messages.wrongOptionType('extraNumericOptionWithoutDefault', 'number', 'string'));
   });
+
+  it('handles a valid application id', async () => {
+    const listener = errorListener();
+    const configIn = { application: { id: 'test-application' } };
+    expect(configuration.validate(configIn, listener.emitter, null, listener.logger).application.id).toEqual(
+      'test-application'
+    );
+  });
+
+  it('logs a warning with an invalid application id', async () => {
+    const listener = errorListener();
+    const configIn = { application: { id: 'test #$#$#' } };
+    expect(configuration.validate(configIn, listener.emitter, null, listener.logger).application.id).toBeUndefined();
+    await listener.expectWarningOnly(messages.invalidTagValue('application.id'));
+  });
+
+  it('handles a valid application version', async () => {
+    const listener = errorListener();
+    const configIn = { application: { version: 'test-version' } };
+    expect(configuration.validate(configIn, listener.emitter, null, listener.logger).application.version).toEqual(
+      'test-version'
+    );
+  });
+
+  it('logs a warning with an invalid application version', async () => {
+    const listener = errorListener();
+    const configIn = { application: { version: 'test #$#$#' } };
+    expect(
+      configuration.validate(configIn, listener.emitter, null, listener.logger).application.version
+    ).toBeUndefined();
+    await listener.expectWarningOnly(messages.invalidTagValue('application.version'));
+  });
+
+  it('includes application id and version in tags when present', async () => {
+    expect(configuration.getTags({ application: { id: 'test-id', version: 'test-version' } })).toEqual({
+      'application-id': ['test-id'],
+      'application-version': ['test-version'],
+    });
+  });
 });

package/src/__tests__/headers-test.js

@@ -0,0 +1,117 @@
+import { getLDHeaders, transformHeaders } from '../headers';
+import { getLDUserAgentString } from '../utils';
+import * as stubPlatform from './stubPlatform';
+
+describe('getLDHeaders', () => {
+  it('sends no headers unless sendLDHeaders is true', () => {
+    const platform = stubPlatform.defaults();
+    const headers = getLDHeaders(platform, {});
+    expect(headers).toEqual({});
+  });
+
+  it('adds user-agent header', () => {
+    const platform = stubPlatform.defaults();
+    const headers = getLDHeaders(platform, { sendLDHeaders: true });
+    expect(headers).toMatchObject({ 'User-Agent': getLDUserAgentString(platform) });
+  });
+
+  it('adds user-agent header with custom name', () => {
+    const platform = stubPlatform.defaults();
+    platform.userAgentHeaderName = 'X-Fake-User-Agent';
+    const headers = getLDHeaders(platform, { sendLDHeaders: true });
+    expect(headers).toMatchObject({ 'X-Fake-User-Agent': getLDUserAgentString(platform) });
+  });
+
+  it('adds wrapper info if specified, without version', () => {
+    const platform = stubPlatform.defaults();
+    const headers = getLDHeaders(platform, { sendLDHeaders: true, wrapperName: 'FakeSDK' });
+    expect(headers).toMatchObject({
+      'User-Agent': getLDUserAgentString(platform),
+      'X-LaunchDarkly-Wrapper': 'FakeSDK',
+    });
+  });
+
+  it('adds wrapper info if specified, with version', () => {
+    const platform = stubPlatform.defaults();
+    const headers = getLDHeaders(platform, { sendLDHeaders: true, wrapperName: 'FakeSDK', wrapperVersion: '9.9' });
+    expect(headers).toMatchObject({
+      'User-Agent': getLDUserAgentString(platform),
+      'X-LaunchDarkly-Wrapper': 'FakeSDK/9.9',
+    });
+  });
+
+  it('sets the X-LaunchDarkly-Tags header with valid id and version.', () => {
+    const platform = stubPlatform.defaults();
+    const headers = getLDHeaders(platform, {
+      sendLDHeaders: true,
+      application: {
+        id: 'test-application',
+        version: 'test-version',
+      },
+    });
+    expect(headers).toMatchObject({
+      'User-Agent': getLDUserAgentString(platform),
+      'x-launchdarkly-tags': 'application-id/test-application application-version/test-version',
+    });
+  });
+
+  it('sets the X-LaunchDarkly-Tags header with just application id', () => {
+    const platform = stubPlatform.defaults();
+    const headers = getLDHeaders(platform, {
+      sendLDHeaders: true,
+      application: {
+        id: 'test-application',
+      },
+    });
+    expect(headers).toMatchObject({
+      'User-Agent': getLDUserAgentString(platform),
+      'x-launchdarkly-tags': 'application-id/test-application',
+    });
+  });
+
+  it('sets the X-LaunchDarkly-Tags header with just application version.', () => {
+    const platform = stubPlatform.defaults();
+    const headers = getLDHeaders(platform, {
+      sendLDHeaders: true,
+      application: {
+        version: 'test-version',
+      },
+    });
+    expect(headers).toMatchObject({
+      'User-Agent': getLDUserAgentString(platform),
+      'x-launchdarkly-tags': 'application-version/test-version',
+    });
+  });
+});
+
+describe('transformHeaders', () => {
+  it('does not modify the headers if the option is not available', () => {
+    const inputHeaders = { a: '1', b: '2' };
+    const headers = transformHeaders(inputHeaders, {});
+    expect(headers).toEqual(inputHeaders);
+  });
+
+  it('modifies the headers if the option has a transform', () => {
+    const inputHeaders = { c: '3', d: '4' };
+    const outputHeaders = { c: '9', d: '4', e: '5' };
+    const headerTransform = input => {
+      const output = { ...input };
+      output['c'] = '9';
+      output['e'] = '5';
+      return output;
+    };
+    const headers = transformHeaders(inputHeaders, { requestHeaderTransform: headerTransform });
+    expect(headers).toEqual(outputHeaders);
+  });
+
+  it('cannot mutate the input header object', () => {
+    const inputHeaders = { f: '6' };
+    const expectedInputHeaders = { f: '6' };
+    const headerMutate = input => {
+      input['f'] = '7'; // eslint-disable-line no-param-reassign
+      return input;
+    };
+    transformHeaders(inputHeaders, { requestHeaderTransform: headerMutate });
+    expect(inputHeaders).toEqual(expectedInputHeaders);
+  });
+});

package/src/__tests__/utils-test.js

@@ -1,7 +1,6 @@
 import {
+  appendUrlPath,
   base64URLEncode,
-  getLDHeaders,
-  transformHeaders,
   getLDUserAgentString,
   wrapPromiseCallback,
   chunkUserEventsForUrl,
@@ -10,6 +9,13 @@ import {
 import * as stubPlatform from './stubPlatform';
 
 describe('utils', () => {
+  it('appendUrlPath', () => {
+    expect(appendUrlPath('http://base', '/path')).toEqual('http://base/path');
+    expect(appendUrlPath('http://base', 'path')).toEqual('http://base/path');
+    expect(appendUrlPath('http://base/', '/path')).toEqual('http://base/path');
+    expect(appendUrlPath('http://base/', '/path')).toEqual('http://base/path');
+  });
+
   describe('wrapPromiseCallback', () => {
     it('should resolve to the value', done => {
       const promise = wrapPromiseCallback(Promise.resolve('woohoo'));
@@ -48,83 +54,12 @@ describe('utils', () => {
     });
   });
 
-  describe('getLDHeaders', () => {
-    it('sends no headers unless sendLDHeaders is true', () => {
-      const platform = stubPlatform.defaults();
-      const headers = getLDHeaders(platform, {});
-      expect(headers).toEqual({});
-    });
-
-    it('adds user-agent header', () => {
-      const platform = stubPlatform.defaults();
-      const headers = getLDHeaders(platform, { sendLDHeaders: true });
-      expect(headers).toMatchObject({ 'User-Agent': getLDUserAgentString(platform) });
-    });
-
-    it('adds user-agent header with custom name', () => {
-      const platform = stubPlatform.defaults();
-      platform.userAgentHeaderName = 'X-Fake-User-Agent';
-      const headers = getLDHeaders(platform, { sendLDHeaders: true });
-      expect(headers).toMatchObject({ 'X-Fake-User-Agent': getLDUserAgentString(platform) });
-    });
-
-    it('adds wrapper info if specified, without version', () => {
-      const platform = stubPlatform.defaults();
-      const headers = getLDHeaders(platform, { sendLDHeaders: true, wrapperName: 'FakeSDK' });
-      expect(headers).toMatchObject({
-        'User-Agent': getLDUserAgentString(platform),
-        'X-LaunchDarkly-Wrapper': 'FakeSDK',
-      });
-    });
-
-    it('adds wrapper info if specified, with version', () => {
-      const platform = stubPlatform.defaults();
-      const headers = getLDHeaders(platform, { sendLDHeaders: true, wrapperName: 'FakeSDK', wrapperVersion: '9.9' });
-      expect(headers).toMatchObject({
-        'User-Agent': getLDUserAgentString(platform),
-        'X-LaunchDarkly-Wrapper': 'FakeSDK/9.9',
-      });
-    });
-  });
-
-  describe('transformHeaders', () => {
-    it('does not modify the headers if the option is not available', () => {
-      const inputHeaders = { a: '1', b: '2' };
-      const headers = transformHeaders(inputHeaders, {});
-      expect(headers).toEqual(inputHeaders);
-    });
-
-    it('modifies the headers if the option has a transform', () => {
-      const inputHeaders = { c: '3', d: '4' };
-      const outputHeaders = { c: '9', d: '4', e: '5' };
-      const headerTransform = input => {
-        const output = { ...input };
-        output['c'] = '9';
-        output['e'] = '5';
-        return output;
-      };
-      const headers = transformHeaders(inputHeaders, { requestHeaderTransform: headerTransform });
-      expect(headers).toEqual(outputHeaders);
-    });
-
-    it('cannot mutate the input header object', () => {
-      const inputHeaders = { f: '6' };
-      const expectedInputHeaders = { f: '6' };
-      const headerMutate = input => {
-        input['f'] = '7'; // eslint-disable-line no-param-reassign
-        return input;
-      };
-      transformHeaders(inputHeaders, { requestHeaderTransform: headerMutate });
-      expect(inputHeaders).toEqual(expectedInputHeaders);
-    });
-  });
-
   describe('getLDUserAgentString', () => {
-    it('uses platform user-agent and package version by default', () => {
+    it('uses platform user-agent and unknown version by default', () => {
       const platform = stubPlatform.defaults();
       platform.version = undefined;
       const ua = getLDUserAgentString(platform);
-      expect(ua).toEqual('stubClient/' + VERSION);
+      expect(ua).toEqual('stubClient/?');
     });
 
     it('uses platform user-agent and platform version if provided', () => {

package/src/configuration.js

@@ -38,8 +38,38 @@ const baseOptionDefs = {
   wrapperVersion: { type: 'string' },
   stateProvider: { type: 'object' }, // not a public option, used internally
   autoAliasingOptOut: { default: false },
+  application: { validator: applicationConfigValidator },
 };
 
+/**
+ * Expression to validate characters that are allowed in tag keys and values.
+ */
+const allowedTagCharacters = /^(\w|\.|-)+$/;
+
+/**
+ * Verify that a value meets the requirements for a tag value.
+ * @param {Object} config
+ * @param {string} tagValue
+ */
+function validateTagValue(name, config, tagValue, logger) {
+  if (typeof tagValue !== 'string' || !tagValue.match(allowedTagCharacters)) {
+    logger.warn(messages.invalidTagValue(name));
+    return undefined;
+  }
+  return tagValue;
+}
+
+function applicationConfigValidator(name, config, value, logger) {
+  const validated = {};
+  if (value.id) {
+    validated.id = validateTagValue(`${name}.id`, config, value.id, logger);
+  }
+  if (value.version) {
+    validated.version = validateTagValue(`${name}.version`, config, value.version, logger);
+  }
+  return validated;
+}
+
 function validate(options, emitter, extraOptionDefs, logger) {
   const optionDefs = utils.extend({ logger: { default: logger } }, baseOptionDefs, extraOptionDefs);
 
@@ -104,7 +134,15 @@ function validate(options, emitter, extraOptionDefs, logger) {
           reportArgumentError(messages.unknownOption(name));
         } else {
           const expectedType = optionDef.type || typeDescForValue(optionDef.default);
-          if (expectedType !== 'any') {
+          const validator = optionDef.validator;
+          if (validator) {
+            const validated = validator(name, config, config[name], logger);
+            if (validated !== undefined) {
+              ret[name] = validated;
+            } else {
+              delete ret[name];
+            }
+          } else if (expectedType !== 'any') {
             const allowedTypes = expectedType.split('|');
             const actualType = typeDescForValue(value);
             if (allowedTypes.indexOf(actualType) < 0) {
@@ -145,7 +183,30 @@ function validate(options, emitter, extraOptionDefs, logger) {
   return config;
 }
 
+/**
+ * Get tags for the specified configuration.
+ *
+ * If any additional tags are added to the configuration, then the tags from
+ * this method should be extended with those.
+ * @param {Object} config The already valiated configuration.
+ * @returns {Object} The tag configuration.
+ */
+function getTags(config) {
+  const tags = {};
+  if (config) {
+    if (config.application && config.application.id !== undefined && config.application.id !== null) {
+      tags['application-id'] = [config.application.id];
+    }
+    if (config.application && config.application.version !== undefined && config.application.id !== null) {
+      tags['application-version'] = [config.application.version];
+    }
+  }
+
+  return tags;
+}
+
 module.exports = {
   baseOptionDefs,
   validate,
+  getTags,
 };

package/src/diagnosticEvents.js

@@ -5,6 +5,7 @@ const { v1: uuidv1 } = require('uuid');
 
 const { baseOptionDefs } = require('./configuration');
 const messages = require('./messages');
+const { appendUrlPath } = require('./utils');
 
 function DiagnosticId(sdkKey) {
   const ret = {
@@ -80,7 +81,7 @@ function DiagnosticsManager(
 ) {
   const combinedMode = !!platform.diagnosticUseCombinedEvent;
   const localStorageKey = 'ld:' + environmentId + ':$diagnostics';
-  const diagnosticEventsUrl = config.eventsUrl + '/events/diagnostic/' + environmentId;
+  const diagnosticEventsUrl = appendUrlPath(config.eventsUrl, '/events/diagnostic/' + environmentId);
   const periodicInterval = config.diagnosticRecordingInterval;
   const acc = accumulator;
   const initialEventSamplingInterval = 4; // used only in combined mode - see start()

package/src/errors.js

@@ -18,6 +18,7 @@ const LDInvalidUserError = createCustomError('LaunchDarklyInvalidUserError');
 const LDInvalidEventKeyError = createCustomError('LaunchDarklyInvalidEventKeyError');
 const LDInvalidArgumentError = createCustomError('LaunchDarklyInvalidArgumentError');
 const LDFlagFetchError = createCustomError('LaunchDarklyFlagFetchError');
+const LDInvalidDataError = createCustomError('LaunchDarklyInvalidDataError');
 
 function isHttpErrorRecoverable(status) {
   if (status >= 400 && status < 500) {
@@ -32,6 +33,7 @@ module.exports = {
   LDInvalidUserError,
   LDInvalidEventKeyError,
   LDInvalidArgumentError,
+  LDInvalidDataError,
   LDFlagFetchError,
   isHttpErrorRecoverable,
 };

package/src/headers.js

@@ -0,0 +1,38 @@
+const { getLDUserAgentString } = require('./utils');
+const configuration = require('./configuration');
+
+function getLDHeaders(platform, options) {
+  if (options && !options.sendLDHeaders) {
+    return {};
+  }
+  const h = {};
+  h[platform.userAgentHeaderName || 'User-Agent'] = getLDUserAgentString(platform);
+  if (options && options.wrapperName) {
+    h['X-LaunchDarkly-Wrapper'] = options.wrapperVersion
+      ? options.wrapperName + '/' + options.wrapperVersion
+      : options.wrapperName;
+  }
+  const tags = configuration.getTags(options);
+  const tagKeys = Object.keys(tags);
+  if (tagKeys.length) {
+    h['x-launchdarkly-tags'] = tagKeys
+      .sort()
+      .flatMap(
+        key => (Array.isArray(tags[key]) ? tags[key].sort().map(value => `${key}/${value}`) : [`${key}/${tags[key]}`])
+      )
+      .join(' ');
+  }
+  return h;
+}
+
+function transformHeaders(headers, options) {
+  if (!options || !options.requestHeaderTransform) {
+    return headers;
+  }
+  return options.requestHeaderTransform({ ...headers });
+}
+
+module.exports = {
+  getLDHeaders,
+  transformHeaders,
+};

package/src/index.js

@@ -386,6 +386,14 @@ function initialize(env, user, specifiedOptions, platform, extraOptionDefs) {
     if (!ident.getUser()) {
       return;
     }
+    const tryParseData = jsonData => {
+      try {
+        return JSON.parse(jsonData);
+      } catch (err) {
+        emitter.maybeReportError(new errors.LDInvalidDataError(messages.invalidData()));
+        return undefined;
+      }
+    };
     stream.connect(ident.getUser(), hash, {
       ping: function() {
         logger.debug(messages.debugStreamPing());
@@ -404,12 +412,20 @@ function initialize(env, user, specifiedOptions, platform, extraOptionDefs) {
           });
       },
       put: function(e) {
-        const data = JSON.parse(e.data);
+        const data = tryParseData(e.data);
+        if (!data) {
+          return;
+        }
         logger.debug(messages.debugStreamPut());
-        replaceAllFlags(data); // don't wait for this Promise to be resolved
+        replaceAllFlags(data);
+        // Don't wait for this Promise to be resolved; note that replaceAllFlags is guaranteed
+        // never to have an unhandled rejection
       },
       patch: function(e) {
-        const data = JSON.parse(e.data);
+        const data = tryParseData(e.data);
+        if (!data) {
+          return;
+        }
         // If both the flag and the patch have a version property, then the patch version must be
         // greater than the flag version for us to accept the patch.  If either one has no version
         // then the patch always succeeds.
@@ -432,7 +448,10 @@ function initialize(env, user, specifiedOptions, platform, extraOptionDefs) {
         }
       },
       delete: function(e) {
-        const data = JSON.parse(e.data);
+        const data = tryParseData(e.data);
+        if (!data) {
+          return;
+        }
         if (!flags[data.key] || flags[data.key].version < data.version) {
           logger.debug(messages.debugStreamDelete(data.key));
           const mods = {};
@@ -760,13 +779,10 @@ function initialize(env, user, specifiedOptions, platform, extraOptionDefs) {
   };
 }
 
-const version = VERSION;
-
 module.exports = {
   initialize,
   commonBasicLogger,
   errors,
   messages,
   utils,
-  version,
 };

package/src/messages.js

@@ -68,6 +68,10 @@ const invalidUser = function() {
   return 'Invalid user specified.' + docLink;
 };
 
+const invalidData = function() {
+  return 'Invalid data received from LaunchDarkly; connection may have been interrupted';
+};
+
 const bootstrapOldFormat = function() {
   return (
     'LaunchDarkly client was initialized with bootstrap data that did not include flag metadata. ' +
@@ -176,6 +180,8 @@ const debugPostingDiagnosticEvent = function(event) {
   return 'sending diagnostic event (' + event.kind + ')';
 };
 
+const invalidTagValue = name => `Config option "${name}" must only contain letters, numbers, ., _ or -.`;
+
 module.exports = {
   bootstrapInvalid,
   bootstrapOldFormat,
@@ -201,7 +207,9 @@ module.exports = {
   httpUnavailable,
   identifyDisabled,
   invalidContentType,
+  invalidData,
   invalidKey,
+  invalidTagValue,
   invalidUser,
   localStorageUnavailable,
   networkError,

package/src/utils.js

@@ -3,6 +3,13 @@ const fastDeepEqual = require('fast-deep-equal');
 
 const userAttrsToStringify = ['key', 'secondary', 'ip', 'country', 'email', 'firstName', 'lastName', 'avatar', 'name'];
 
+function appendUrlPath(baseUrl, path) {
+  // Ensure that URL concatenation is done correctly regardless of whether the
+  // base URL has a trailing slash or not.
+  const trimBaseUrl = baseUrl.endsWith('/') ? baseUrl.substring(0, baseUrl.length - 1) : baseUrl;
+  return trimBaseUrl + (path.startsWith('/') ? '' : '/') + path;
+}
+
 // See http://ecmanaut.blogspot.com/2006/07/encoding-decoding-utf8-in-javascript.html
 function btoa(s) {
   const escaped = unescape(encodeURIComponent(s));
@@ -146,31 +153,10 @@ function chunkUserEventsForUrl(maxLength, events) {
 }
 
 function getLDUserAgentString(platform) {
-  const version = platform.version || VERSION;
+  const version = platform.version || '?';
   return platform.userAgent + '/' + version;
 }
 
-function getLDHeaders(platform, options) {
-  if (options && !options.sendLDHeaders) {
-    return {};
-  }
-  const h = {};
-  h[platform.userAgentHeaderName || 'User-Agent'] = getLDUserAgentString(platform);
-  if (options && options.wrapperName) {
-    h['X-LaunchDarkly-Wrapper'] = options.wrapperVersion
-      ? options.wrapperName + '/' + options.wrapperVersion
-      : options.wrapperName;
-  }
-  return h;
-}
-
-function transformHeaders(headers, options) {
-  if (!options || !options.requestHeaderTransform) {
-    return headers;
-  }
-  return options.requestHeaderTransform({ ...headers });
-}
-
 function extend(...objects) {
   return objects.reduce((acc, obj) => ({ ...acc, ...obj }), {});
 }
@@ -196,18 +182,17 @@ function sanitizeUser(user) {
 }
 
 module.exports = {
+  appendUrlPath,
   base64URLEncode,
   btoa,
   chunkUserEventsForUrl,
   clone,
   deepEquals,
   extend,
-  getLDHeaders,
   getLDUserAgentString,
   objectHasOwnProperty,
   onNextTick,
   sanitizeUser,
-  transformHeaders,
   transformValuesToVersionedValues,
   transformVersionedValuesToValues,
   wrapPromiseCallback,

package/test-types.ts

@@ -4,8 +4,6 @@
 
 import * as ld from 'launchdarkly-js-sdk-common';
 
-var ver: string = ld.version;
-
 var userWithKeyOnly: ld.LDUser = { key: 'user' };
 var anonUserWithNoKey: ld.LDUser = { anonymous: true };
 var anonUserWithKey: ld.LDUser = { key: 'anon-user', anonymous: true };
@@ -49,7 +47,11 @@ var allBaseOptions: ld.LDOptionsBase = {
   sendEventsOnlyForVariation: true,
   flushInterval: 1,
   streamReconnectDelay: 1,
-  logger: logger
+  logger: logger,
+  application: {
+    version: 'version',
+    id: 'id'
+  }
 };
 
 var client: ld.LDClientBase = {} as ld.LDClientBase;  // wouldn't do this in real life, it's just so the following statements will compile

package/typings.d.ts

@@ -2,12 +2,6 @@
  * Basic LaunchDarkly JavaScript client interfaces, shared between the browser SDK and the Electron SDK.
  */
 declare module 'launchdarkly-js-sdk-common' {
-
-  /**
-   * The current version string of the SDK.
-   */
-  export const version: string;
-
   /**
    * The types of values a feature flag can have.
    *
@@ -121,10 +115,14 @@ declare module 'launchdarkly-js-sdk-common' {
     /**
      * Whether or not to include custom HTTP headers when requesting flags from LaunchDarkly.
      *
-     * Currently these are used to track what version of the SDK is active. This defaults to true
-     * (custom headers will be sent). One reason you might want to set it to false is that the presence
-     * of custom headers causes browsers to make an extra OPTIONS request (a CORS preflight check)
-     * before each flag request, which could affect performance.
+     * These are used to send metadata about the SDK (such as the version). They
+     * are also used to send the application.id and application.version set in
+     * the options.
+     * 
+     * This defaults to true (custom headers will be sent). One reason you might
+     * want to set it to false is that the presence of custom headers causes
+     * browsers to make an extra OPTIONS request (a CORS preflight check) before
+     * each flag request, which could affect performance.
      */
     sendLDHeaders?: boolean;
 
@@ -261,6 +259,31 @@ declare module 'launchdarkly-js-sdk-common' {
      * The default value is `false`.
      */
     autoAliasingOptOut?: boolean;
+
+    /**
+     * Information about the application where the LaunchDarkly SDK is running.
+     */
+    application?: {
+      /**
+       * A unique identifier representing the application where the LaunchDarkly SDK is running.
+       * 
+       * This can be specified as any string value as long as it only uses the following characters: ASCII letters,
+       * ASCII digits, period, hyphen, underscore. A string containing any other characters will be ignored.
+       * 
+       * Example: `authentication-service`
+       */
+      id?: string;
+
+      /**
+       * A unique identifier representing the version of the application where the LaunchDarkly SDK is running.
+       * 
+       * This can be specified as any string value as long as it only uses the following characters: ASCII letters,
+       * ASCII digits, period, hyphen, underscore. A string containing any other characters will be ignored.
+       * 
+       * Example: `1.0.0` (standard version string) or `abcdef` (sha prefix)
+       */
+      version?: string;
+    }
   }
 
   /**