launchdarkly-js-sdk-common 5.7.0-beta.2 → 5.7.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "launchdarkly-js-sdk-common",
-  "version": "5.7.0-beta.2",
+  "version": "5.7.0-beta.4",
   "description": "LaunchDarkly SDK for JavaScript - common code",
   "author": "LaunchDarkly <team@launchdarkly.com>",
   "license": "Apache-2.0",

package/src/EventProcessor.js

@@ -5,7 +5,6 @@ const errors = require('./errors');
 const messages = require('./messages');
 const utils = require('./utils');
 const { getContextKeys } = require('./context');
-const EventSummarizer = require('./EventSummarizer');
 
 function EventProcessor(
   platform,
@@ -19,12 +18,7 @@ function EventProcessor(
   const eventSender = sender || EventSender(platform, environmentId, options);
   const mainEventsUrl = utils.appendUrlPath(options.eventsUrl, '/events/bulk/' + environmentId);
   const contextFilter = ContextFilter(options);
-  // If the platform has a hasherFactory, use the MultiEventSummarizer, otherwise use the EventSummarizer.
-  // Generally packages should be pinning a specific version of the common SDK, but this will handle them potentially
-  // being mis-matched.
-  const summarizer = platform.hasherFactory
-    ? MultiEventSummarizer(contextFilter, () => platform.hasherFactory('sha256'))
-    : new EventSummarizer();
+  const summarizer = MultiEventSummarizer(contextFilter);
   const samplingInterval = options.samplingInterval;
   const eventCapacity = options.eventCapacity;
   const flushInterval = options.flushInterval;
@@ -128,7 +122,7 @@ function EventProcessor(
       return Promise.resolve();
     }
     const eventsToSend = queue;
-    const summaries = await summarizer.getSummaries();
+    const summaries = summarizer.getSummaries();
 
     summaries.forEach(summary => {
       if (Object.keys(summary.features).length) {

package/src/EventSummarizer.js

@@ -93,13 +93,6 @@ function EventSummarizer() {
         };
   };
 
-  es.getSummaries = () => {
-    const summary = es.getSummary();
-    const summaries = summary ? [summary] : [];
-    es.clearSummary();
-    return summaries;
-  };
-
   es.clearSummary = () => {
     startDate = 0;
     endDate = 0;

package/src/MultiEventSummarizer.js

@@ -1,14 +1,14 @@
-import { hashContext } from './context';
-import EventSummarizer from './EventSummarizer';
+const canonicalize = require('./canonicalize');
+const EventSummarizer = require('./EventSummarizer');
+
 /**
  *
  * @param {{filter: (context: any) => any}} contextFilter
  * @param {() => {update: (value: string) => void, digest: (format: string) => Promise<string>}} hasherFactory
  */
-function MultiEventSummarizer(contextFilter, hasherFactory) {
+function MultiEventSummarizer(contextFilter) {
   let summarizers = {};
   let contexts = {};
-  const pendingPromises = [];
 
   /**
    * Summarize the given event.
@@ -18,51 +18,36 @@ function MultiEventSummarizer(contextFilter, hasherFactory) {
    * }} event
    */
   function summarizeEvent(event) {
-    // This will execute asynchronously, which means that a flush could happen before the event
-    // is summarized. When that happens, then the event will just be in the next batch of summaries.
-    const promise = (async () => {
-      if (event.kind === 'feature') {
-        const hash = await hashContext(event.context, hasherFactory());
-        if (!hash) {
-          return;
-        }
-
-        let summarizer = summarizers[hash];
-        if (!summarizer) {
-          summarizers[hash] = EventSummarizer();
-          summarizer = summarizers[hash];
-          contexts[hash] = event.context;
-        }
-
-        summarizer.summarizeEvent(event);
+    if (event.kind === 'feature') {
+      const key = canonicalize(event.context);
+      if (!key) {
+        return;
       }
-    })();
-    pendingPromises.push(promise);
-    promise.finally(() => {
-      const index = pendingPromises.indexOf(promise);
-      if (index !== -1) {
-        pendingPromises.splice(index, 1);
+
+      let summarizer = summarizers[key];
+      if (!summarizer) {
+        summarizers[key] = EventSummarizer();
+        summarizer = summarizers[key];
+        contexts[key] = event.context;
       }
-    });
+
+      summarizer.summarizeEvent(event);
+    }
   }
 
   /**
    * Get the summaries of the events that have been summarized.
    * @returns {any[]}
    */
-  async function getSummaries() {
-    // Wait for any pending summarizations to complete
-    // Additional tasks queued while waiting will not be waited for.
-    await Promise.all([...pendingPromises]);
-
+  function getSummaries() {
     const summarizersToFlush = summarizers;
     const contextsForSummaries = contexts;
 
     summarizers = {};
     contexts = {};
-    return Object.entries(summarizersToFlush).map(([hash, summarizer]) => {
+    return Object.entries(summarizersToFlush).map(([key, summarizer]) => {
       const summary = summarizer.getSummary();
-      summary.context = contextFilter.filter(contextsForSummaries[hash]);
+      summary.context = contextFilter.filter(contextsForSummaries[key]);
       return summary;
     });
   }

package/src/__tests__/EventProcessor-test.js

@@ -485,6 +485,73 @@ describe.each([
     });
   });
 
+  it('generates separate summary events for different contexts', async () => {
+    await withProcessorAndSender(defaultConfig, async (ep, mockEventSender) => {
+      const context1 = { key: 'user1', kind: 'user' };
+      const context2 = { key: 'user2', kind: 'user' };
+
+      // Create feature events for two different contexts
+      const event1 = {
+        kind: 'feature',
+        creationDate: 1000,
+        context: context1,
+        key: 'flag1',
+        version: 11,
+        variation: 1,
+        value: 'value1',
+        default: 'default1',
+        trackEvents: false,
+      };
+
+      const event2 = {
+        kind: 'feature',
+        creationDate: 1000,
+        context: context2,
+        key: 'flag2',
+        version: 22,
+        variation: 2,
+        value: 'value2',
+        default: 'default2',
+        trackEvents: false,
+      };
+
+      ep.enqueue(event1);
+      ep.enqueue(event2);
+      await ep.flush();
+
+      expect(mockEventSender.calls.length()).toEqual(1);
+      const output = (await mockEventSender.calls.take()).events;
+
+      // Should have two summary events, one for each context
+      expect(output.length).toEqual(2);
+
+      // Find the summary event for each context
+      const summary1 = output.find(e => e.context.key === 'user1');
+      const summary2 = output.find(e => e.context.key === 'user2');
+
+      // Verify each summary event has the correct context and flag data
+      expect(summary1).toBeDefined();
+      expect(summary1.context).toEqual(context1);
+      expect(summary1.features).toEqual({
+        flag1: {
+          contextKinds: ['user'],
+          default: 'default1',
+          counters: [{ version: 11, variation: 1, value: 'value1', count: 1 }],
+        },
+      });
+
+      expect(summary2).toBeDefined();
+      expect(summary2.context).toEqual(context2);
+      expect(summary2.features).toEqual({
+        flag2: {
+          contextKinds: ['user'],
+          default: 'default2',
+          counters: [{ version: 22, variation: 2, value: 'value2', count: 1 }],
+        },
+      });
+    });
+  });
+
   describe('interaction with diagnostic events', () => {
     it('sets eventsInLastBatch on flush', async () => {
       const e0 = { kind: 'custom', creationDate: 1000, context: eventContext, key: 'key0' };
@@ -526,92 +593,7 @@ describe.each([
       });
     });
 
-    it('uses EventSummarizer when platform has no hasherFactory', async () => {
-      const event = {
-        kind: 'feature',
-        creationDate: 1000,
-        context: eventContext,
-        key: 'flagkey',
-        version: 11,
-        variation: 1,
-        value: 'value',
-        default: 'default',
-        trackEvents: true,
-      };
-
-      const platformWithoutHasher = { ...platform };
-      delete platformWithoutHasher.hasherFactory;
-
-      const sender = MockEventSender();
-      const ep = EventProcessor(platformWithoutHasher, defaultConfig, envId, null, null, sender);
-      try {
-        ep.enqueue(event);
-        await ep.flush();
-
-        expect(sender.calls.length()).toEqual(1);
-        const output = (await sender.calls.take()).events;
-        expect(output.length).toEqual(2);
-        checkFeatureEvent(output[0], event, false, eventContext);
-        checkSummaryEvent(output[1]);
-
-        // Verify the summary event doesn't have a context field when there's no hasherFactory
-        const summaryEvent = output[1];
-        expect(summaryEvent.context).toBeUndefined();
-        expect(summaryEvent.features).toEqual({
-          flagkey: {
-            contextKinds: ['user'],
-            default: 'default',
-            counters: [{ version: 11, variation: 1, value: 'value', count: 1 }],
-          },
-        });
-      } finally {
-        ep.stop();
-      }
-    });
-
-    it('uses MultiEventSummarizer when platform has hasherFactory', async () => {
-      const event = {
-        kind: 'feature',
-        creationDate: 1000,
-        context: eventContext,
-        key: 'flagkey',
-        version: 11,
-        variation: 1,
-        value: 'value',
-        default: 'default',
-        trackEvents: true,
-      };
-
-      // Stub platform hash a hasher factory.
-
-      const sender = MockEventSender();
-      const ep = EventProcessor(platform, defaultConfig, envId, null, null, sender);
-      try {
-        ep.enqueue(event);
-        await ep.flush();
-
-        expect(sender.calls.length()).toEqual(1);
-        const output = (await sender.calls.take()).events;
-        expect(output.length).toEqual(2);
-        checkFeatureEvent(output[0], event, false, eventContext);
-        checkSummaryEvent(output[1]);
-
-        // Verify that when MultiEventSummarizer is used, context is included in the summary
-        const summaryEvent = output[1];
-        expect(summaryEvent.context).toEqual(eventContext);
-        expect(summaryEvent.features).toEqual({
-          flagkey: {
-            contextKinds: ['user'],
-            default: 'default',
-            counters: [{ version: 11, variation: 1, value: 'value', count: 1 }],
-          },
-        });
-      } finally {
-        ep.stop();
-      }
-    });
-
-    it('filters context in summary events when using MultiEventSummarizer', async () => {
+    it('filters context in summary events', async () => {
       const event = {
         kind: 'feature',
         creationDate: 1000,

package/src/__tests__/EventSummarizer-test.js

@@ -33,38 +33,6 @@ describe('EventSummarizer', () => {
     expect(data.endDate).toEqual(2000);
   });
 
-  it('returns summaries for feature events', () => {
-    // getSummaries returns the single summary from getSummary(), but wrapped in an array.
-    const es = EventSummarizer();
-    const event1 = { kind: 'feature', creationDate: 2000, key: 'key', user: user };
-    const event2 = { kind: 'feature', creationDate: 1000, key: 'key', user: user };
-    const event3 = { kind: 'feature', creationDate: 1500, key: 'key', user: user };
-    es.summarizeEvent(event1);
-    es.summarizeEvent(event2);
-    es.summarizeEvent(event3);
-    const summaries = es.getSummaries();
-
-    expect(summaries[0].startDate).toEqual(1000);
-    expect(summaries[0].endDate).toEqual(2000);
-  });
-
-  it('clears summaries when getSummaries is called', () => {
-    const es = EventSummarizer();
-    const event1 = { kind: 'feature', creationDate: 2000, key: 'key', user: user };
-    const event2 = { kind: 'feature', creationDate: 1000, key: 'key', user: user };
-    es.summarizeEvent(event1);
-    es.summarizeEvent(event2);
-    const summaries = es.getSummaries();
-    expect(summaries[0].startDate).toEqual(1000);
-    expect(summaries[0].endDate).toEqual(2000);
-    expect(es.getSummaries()).toEqual([]);
-  });
-
-  it('returns empty array if no summaries are available', () => {
-    const es = EventSummarizer();
-    expect(es.getSummaries()).toEqual([]);
-  });
-
   function makeEvent(key, version, variation, value, defaultVal) {
     return {
       kind: 'feature',

package/src/__tests__/context-test.js

@@ -1,4 +1,4 @@
-const { checkContext, getContextKeys, getContextKinds, getCanonicalKey, hashContext } = require('../context');
+const { checkContext, getContextKeys, getContextKinds, getCanonicalKey } = require('../context');
 
 describe.each([{ key: 'test' }, { kind: 'user', key: 'test' }, { kind: 'multi', user: { key: 'test' } }])(
   'given a context which contains a single kind',
@@ -199,332 +199,3 @@ describe('getContextKeys', () => {
     expect(keys).toEqual({});
   });
 });
-
-function mockHasher() {
-  let state = '';
-  return {
-    update: input => {
-      state += input;
-    },
-    digest: () => state,
-  };
-}
-
-it('hashes two equal contexts the same', async () => {
-  const a = {
-    kind: 'multi',
-    org: {
-      key: 'testKey',
-      name: 'testName',
-      cat: 'calico',
-      dog: 'lab',
-      anonymous: true,
-      _meta: {
-        privateAttributes: ['/a/b/c', 'cat', 'custom/dog'],
-      },
-    },
-    customer: {
-      key: 'testKey',
-      name: 'testName',
-      bird: 'party parrot',
-      chicken: 'hen',
-    },
-  };
-
-  const b = {
-    kind: 'multi',
-    org: {
-      key: 'testKey',
-      name: 'testName',
-      cat: 'calico',
-      dog: 'lab',
-      anonymous: true,
-      _meta: {
-        privateAttributes: ['/a/b/c', 'cat', 'custom/dog'],
-      },
-    },
-    customer: {
-      key: 'testKey',
-      name: 'testName',
-      bird: 'party parrot',
-      chicken: 'hen',
-    },
-  };
-  expect(await hashContext(a, mockHasher())).toEqual(await hashContext(b, mockHasher()));
-});
-
-it('handles shared references without getting stuck', async () => {
-  const sharedObject = { value: 'shared' };
-  const context = {
-    kind: 'multi',
-    org: {
-      key: 'testKey',
-      shared: sharedObject,
-    },
-    user: {
-      key: 'testKey',
-      shared: sharedObject,
-    },
-  };
-
-  const hash = await hashContext(context, mockHasher());
-  expect(hash).toBeDefined();
-});
-
-it('returns undefined for contexts with cycles', async () => {
-  const cyclicObject = { value: 'cyclic' };
-  cyclicObject.self = cyclicObject;
-
-  const context = {
-    kind: 'user',
-    key: 'testKey',
-    cyclic: cyclicObject,
-  };
-
-  expect(await hashContext(context, mockHasher())).toBeUndefined();
-});
-
-it('handles nested objects correctly', async () => {
-  const context = {
-    kind: 'user',
-    key: 'testKey',
-    nested: {
-      level1: {
-        level2: {
-          value: 'deep',
-        },
-      },
-    },
-  };
-
-  const hash = await hashContext(context, mockHasher());
-  expect(hash).toBeDefined();
-});
-
-it('handles arrays correctly', async () => {
-  const context = {
-    kind: 'user',
-    key: 'testKey',
-    array: [1, 2, 3],
-    nestedArray: [
-      [1, 2],
-      [3, 4],
-    ],
-  };
-
-  const hash = await hashContext(context, mockHasher());
-  expect(hash).toBeDefined();
-});
-
-it('handles primitive values correctly', async () => {
-  const context = {
-    kind: 'user',
-    key: 'testKey',
-    string: 'test',
-    number: 42,
-    boolean: true,
-    nullValue: null,
-    undefinedValue: undefined,
-  };
-
-  const hash = await hashContext(context, mockHasher());
-  expect(hash).toBeDefined();
-});
-
-it('includes private attributes in hash calculation', async () => {
-  const baseContext = {
-    kind: 'user',
-    key: 'testKey',
-    name: 'testName',
-    nested: {
-      value: 'testValue',
-    },
-  };
-
-  const contextWithPrivate = {
-    ...baseContext,
-    _meta: {
-      privateAttributes: ['name', 'nested/value'],
-    },
-  };
-
-  const hashWithPrivate = await hashContext(contextWithPrivate, mockHasher());
-  const hashWithoutPrivate = await hashContext(baseContext, mockHasher());
-
-  // The hashes should be different because private attributes are included in the hash
-  expect(hashWithPrivate).not.toEqual(hashWithoutPrivate);
-});
-
-it('uses the keys of attributes in the hash', async () => {
-  const a = {
-    kind: 'user',
-    key: 'testKey',
-    a: 'b',
-  };
-
-  const b = {
-    kind: 'user',
-    key: 'testKey',
-    b: 'b',
-  };
-
-  const hashA = await hashContext(a, mockHasher());
-  const hashB = await hashContext(b, mockHasher());
-  expect(hashA).not.toBe(hashB);
-});
-
-it('uses the keys of nested objects inside the hash', async () => {
-  const a = {
-    kind: 'user',
-    key: 'testKey',
-    nested: {
-      level1: {
-        level2: {
-          value: 'deep',
-        },
-      },
-    },
-  };
-
-  const b = {
-    kind: 'user',
-    key: 'testKey',
-    nested: {
-      sub1: {
-        sub2: {
-          value: 'deep',
-        },
-      },
-    },
-  };
-
-  const hashA = await hashContext(a, mockHasher());
-  const hashB = await hashContext(b, mockHasher());
-  expect(hashA).not.toBe(hashB);
-});
-
-it('uses the values of nested array in calculations', async () => {
-  const a = {
-    kind: 'user',
-    key: 'testKey',
-    array: [1, 2, 3],
-    nestedArray: [
-      [1, 2],
-      [3, 4],
-    ],
-  };
-
-  const b = {
-    kind: 'user',
-    key: 'testKey',
-    array: [1, 2, 3],
-    nestedArray: [
-      [2, 1],
-      [3, 4],
-    ],
-  };
-
-  const hashA = await hashContext(a, mockHasher());
-  const hashB = await hashContext(b, mockHasher());
-  expect(hashA).not.toBe(hashB);
-});
-
-it('uses the values of nested objects inside the hash', async () => {
-  const a = {
-    kind: 'user',
-    key: 'testKey',
-    nested: {
-      level1: {
-        level2: {
-          value: 'deep',
-        },
-      },
-    },
-  };
-
-  const b = {
-    kind: 'user',
-    key: 'testKey',
-    nested: {
-      level1: {
-        level2: {
-          value: 'deeper',
-        },
-      },
-    },
-  };
-
-  const hashA = await hashContext(a, mockHasher());
-  const hashB = await hashContext(b, mockHasher());
-  expect(hashA).not.toBe(hashB);
-});
-
-it('hashes _meta in attributes', async () => {
-  const a = {
-    kind: 'user',
-    key: 'testKey',
-    nested: {
-      level1: {
-        level2: {
-          _meta: { test: 'a' },
-        },
-      },
-    },
-  };
-
-  const b = {
-    kind: 'user',
-    key: 'testKey',
-    nested: {
-      level1: {
-        level2: {
-          _meta: { test: 'b' },
-        },
-      },
-    },
-  };
-
-  const hashA = await hashContext(a, mockHasher());
-  const hashB = await hashContext(b, mockHasher());
-  expect(hashA).not.toBe(hashB);
-});
-
-it('produces the same value for the given context', async () => {
-  // This isn't so much a test as it is a detection of change.
-  // If this test failed, and you didn't expect it, then you probably need to make sure your
-  // change makes sense.
-  const complexContext = {
-    kind: 'multi',
-    org: {
-      key: 'testKey',
-      name: 'testName',
-      cat: 'calico',
-      dog: 'lab',
-      anonymous: true,
-      nestedArray: [
-        [1, 2],
-        [3, 4],
-      ],
-      _meta: {
-        privateAttributes: ['/a/b/c', 'cat', 'custom/dog'],
-      },
-    },
-    customer: {
-      key: 'testKey',
-      name: 'testName',
-      bird: 'party parrot',
-      chicken: 'hen',
-      nested: {
-        level1: {
-          level2: {
-            value: 'deep',
-            _meta: { thisShouldBeInTheHash: true },
-          },
-        },
-      },
-    },
-  };
-  expect(await hashContext(complexContext, mockHasher())).toBe(
-    '{"customer":{"bird":"party parrot","chicken":"hen","key":"testKey","name":"testName","nested":{"level1":{"level2":{"_meta":{"thisShouldBeInTheHash":true},"value":"deep"}}}},"kind":"multi","org":{"_meta":{"privateAttributes":["/a/b/c","cat","custom/dog"]},"anonymous":true,"cat":"calico","dog":"lab","key":"testKey","name":"testName","nestedArray":[[1,2],[3,4]]}}'
-  );
-});

package/src/__tests__/stubPlatform.js

@@ -45,15 +45,6 @@ export function defaults() {
     diagnosticPlatformData: { name: 'stub-platform' },
     getCurrentUrl: () => currentUrl,
     isDoNotTrack: () => doNotTrack,
-    hasherFactory: (/*algorithm*/) => {
-      let content = '';
-      return {
-        update: value => {
-          content += value;
-        },
-        digest: (/*format*/) => content,
-      };
-    },
     eventSourceFactory: (url, options) => {
       const es = new EventSource(url);
       es.options = options;

package/src/context.js

@@ -1,5 +1,4 @@
 const { commonBasicLogger } = require('./loggers');
-const canonicalize = require('./canonicalize');
 
 /**
  * Validate a context kind.
@@ -127,45 +126,9 @@ function getContextKeys(context, logger = commonBasicLogger()) {
   return keys;
 }
 
-/**
- * Hash the given context using the provided hasher.
- * This implementation can produce different hashes for equivalent contexts.
- *
- * For example:
- * A legacy user and a single-kind context of user kind that are equivalent, will hash differently.
- * A multi-context with one kind, and the single context with that kind are equivalent, but will hash differently.
- * Two equivalent contexts, with private attributes that are defined in different orders, will hash differently.
- *
- * @param {Object} context
- * @param {{update: (value: string) => void, digest: (format: string) => Promise<string>}} hasher
- * @returns {Promise<string | undefined>} The hash of the context, or undefined if the context is invalid.
- */
-function hashContext(context, hasher) {
-  // In js-core we have legacy and non-legacy contexts hash the same. This implementation does not support that.
-  // Because this implementation directly uses the user-provided context and doesn't manipulate it.
-  // The js-core implementation is more conceptually correct, but it isn't a practical requirement.
-
-  // This implementation additionally doesn't produce the same hash for an equivalent multi-context with one kind, and
-  // the single context with that kind.
-  if (!checkContext(context)) {
-    return undefined;
-  }
-
-  try {
-    const canonicalized = canonicalize(context);
-
-    hasher.update(canonicalized);
-
-    return hasher.digest('hex');
-  } catch {
-    return undefined;
-  }
-}
-
 module.exports = {
   checkContext,
   getContextKeys,
   getContextKinds,
   getCanonicalKey,
-  hashContext,
 };