launchdarkly-js-sdk-common 5.7.0-beta.1 → 5.7.0-beta.3

package/package.json

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

package/src/EventProcessor.js

@@ -5,6 +5,7 @@ const errors = require('./errors');
 const messages = require('./messages');
 const utils = require('./utils');
 const { getContextKeys } = require('./context');
+const EventSummarizer = require('./EventSummarizer');
 
 function EventProcessor(
   platform,
@@ -18,7 +19,12 @@ function EventProcessor(
   const eventSender = sender || EventSender(platform, environmentId, options);
   const mainEventsUrl = utils.appendUrlPath(options.eventsUrl, '/events/bulk/' + environmentId);
   const contextFilter = ContextFilter(options);
-  const summarizer = MultiEventSummarizer(contextFilter, () => platform.hasherFactory('sha256'));
+  // 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 samplingInterval = options.samplingInterval;
   const eventCapacity = options.eventCapacity;
   const flushInterval = options.flushInterval;
@@ -129,12 +135,7 @@ function EventProcessor(
         eventsToSend.push(summary);
       }
     });
-    // const summary = summarizer.getSummary();
-    // summarizer.clearSummary();
-    // if (summary) {
-    //   summary.kind = 'summary';
-    //   eventsToSend.push(summary);
-    // }
+
     if (diagnosticsAccumulator) {
       // For diagnostic events, we record how many events were in the queue at the last flush (since "how
       // many events happened to be in the queue at the moment we decided to send a diagnostic event" would

package/src/EventSummarizer.js

@@ -93,6 +93,13 @@ 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,5 +1,6 @@
-import { hashContext } from './context';
-import EventSummarizer from './EventSummarizer';
+const { hashContext } = require('./context');
+const EventSummarizer = require('./EventSummarizer');
+
 /**
  *
  * @param {{filter: (context: any) => any}} contextFilter

package/src/__tests__/EventProcessor-test.js

@@ -525,5 +525,135 @@ describe.each([
         expect(diagnosticAccumulator.getProps().droppedEvents).toEqual(2);
       });
     });
+
+    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 () => {
+      const event = {
+        kind: 'feature',
+        creationDate: 1000,
+        context: eventContext,
+        key: 'flagkey',
+        version: 11,
+        variation: 1,
+        value: 'value',
+        default: 'default',
+        trackEvents: true,
+      };
+
+      // Configure with allAttributesPrivate set to true
+      const config = { ...defaultConfig, allAttributesPrivate: true };
+
+      const sender = MockEventSender();
+      const ep = EventProcessor(platform, config, 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);
+
+        // Verify the feature event has filtered context
+        checkFeatureEvent(output[0], event, false, filteredContext);
+
+        // Verify the summary event has filtered context
+        const summaryEvent = output[1];
+        checkSummaryEvent(summaryEvent);
+        expect(summaryEvent.context).toEqual(filteredContext);
+        expect(summaryEvent.features).toEqual({
+          flagkey: {
+            contextKinds: ['user'],
+            default: 'default',
+            counters: [{ version: 11, variation: 1, value: 'value', count: 1 }],
+          },
+        });
+      } finally {
+        ep.stop();
+      }
+    });
   });
 });

package/src/__tests__/EventSummarizer-test.js

@@ -33,6 +33,38 @@ 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',