@launchdarkly/js-sdk-common 2.17.0 → 2.18.0

package/dist/esm/index.mjs

@@ -115,6 +115,9 @@ class AttributeReference {
         return (this.depth === other.depth &&
             this._components.every((value, index) => value === other.getComponent(index)));
     }
+    get components() {
+        return [...this._components];
+    }
 }
 /**
  * For use as invalid references when deserializing Flag/Segment data.
@@ -314,6 +317,41 @@ function isLegacyUser(context) {
     return !('kind' in context) || context.kind === null || context.kind === undefined;
 }
 
+/**
+ * Given some object to serialize product a canonicalized JSON string.
+ * https://www.rfc-editor.org/rfc/rfc8785.html
+ *
+ * We do not support custom toJSON methods on objects. Objects should be limited to basic types.
+ *
+ * @param object The object to serialize.
+ */
+function canonicalize(object, visited = []) {
+    // For JavaScript the default JSON serialization will produce canonicalized output for basic types.
+    if (object === null || typeof object !== 'object') {
+        return JSON.stringify(object);
+    }
+    if (visited.includes(object)) {
+        throw new Error('Cycle detected');
+    }
+    if (Array.isArray(object)) {
+        const values = object
+            .map((item) => canonicalize(item, [...visited, object]))
+            .map((item) => (item === undefined ? 'null' : item));
+        return `[${values.join(',')}]`;
+    }
+    const values = Object.keys(object)
+        .sort()
+        .map((key) => {
+        const value = canonicalize(object[key], [...visited, object]);
+        if (value !== undefined) {
+            return `${JSON.stringify(key)}:${value}`;
+        }
+        return undefined;
+    })
+        .filter((item) => item !== undefined);
+    return `{${values.join(',')}}`;
+}
+
 // The general strategy for the context is to transform the passed in context
 // as little as possible. We do convert the legacy users to a single kind
 // context, but we do not translate all passed contexts into a rigid structure.
@@ -688,6 +726,28 @@ class Context {
     get legacy() {
         return this._wasLegacy;
     }
+    /**
+     * Get the serialized canonical JSON for this context. This is not filtered for use in events.
+     *
+     * This method will cache the result.
+     *
+     * @returns The serialized canonical JSON or undefined if it cannot be serialized.
+     */
+    canonicalUnfilteredJson() {
+        if (!this.valid) {
+            return undefined;
+        }
+        if (this._cachedCanonicalJson) {
+            return this._cachedCanonicalJson;
+        }
+        try {
+            this._cachedCanonicalJson = canonicalize(Context.toLDContext(this));
+        }
+        catch {
+            // Indicated by undefined being returned.
+        }
+        return this._cachedCanonicalJson;
+    }
 }
 Context.UserKind = DEFAULT_KIND;
 
@@ -2351,7 +2411,9 @@ function counterKey(event) {
  * @internal
  */
 class EventSummarizer {
-    constructor() {
+    constructor(_singleContext = false, _contextFilter) {
+        this._singleContext = _singleContext;
+        this._contextFilter = _contextFilter;
         this._startDate = 0;
         this._endDate = 0;
         this._counters = {};
@@ -2359,6 +2421,9 @@ class EventSummarizer {
     }
     summarizeEvent(event) {
         if (isFeature(event) && !event.excludeFromSummaries) {
+            if (!this._context) {
+                this._context = event.context;
+            }
             const countKey = counterKey(event);
             const counter = this._counters[countKey];
             let kinds = this._contextKinds[event.key];
@@ -2408,14 +2473,19 @@ class EventSummarizer {
             flagSummary.counters.push(counterOut);
             return acc;
         }, {});
-        return {
+        const event = {
             startDate: this._startDate,
             endDate: this._endDate,
             features,
             kind: 'summary',
+            context: this._context !== undefined && this._singleContext
+                ? this._contextFilter?.filter(this._context)
+                : undefined,
         };
+        this._clearSummary();
+        return event;
     }
-    clearSummary() {
+    _clearSummary() {
         this._startDate = 0;
         this._endDate = 0;
         this._counters = {};
@@ -2430,6 +2500,38 @@ class LDInvalidSDKKeyError extends Error {
     }
 }
 
+class MultiEventSummarizer {
+    constructor(_contextFilter, _logger) {
+        this._contextFilter = _contextFilter;
+        this._logger = _logger;
+        this._summarizers = {};
+    }
+    summarizeEvent(event) {
+        if (isFeature(event)) {
+            const key = event.context.canonicalUnfilteredJson();
+            if (!key) {
+                if (event.context.valid) {
+                    // The context appeared valid, but it could not be hashed.
+                    // This is likely because of a cycle in the data.
+                    this._logger?.error('Unable to serialize context, likely the context contains a cycle.');
+                }
+                return;
+            }
+            let summarizer = this._summarizers[key];
+            if (!summarizer) {
+                this._summarizers[key] = new EventSummarizer(true, this._contextFilter);
+                summarizer = this._summarizers[key];
+            }
+            summarizer.summarizeEvent(event);
+        }
+    }
+    getSummaries() {
+        const summarizersToFlush = this._summarizers;
+        this._summarizers = {};
+        return Object.values(summarizersToFlush).map((summarizer) => summarizer.getSummary());
+    }
+}
+
 /**
  * The contents of this file are for event sampling. They are not used for
  * any purpose requiring cryptographic security.
@@ -2450,12 +2552,14 @@ function shouldSample(ratio) {
     return Math.floor(Math.random() * truncated) === 0;
 }
 
+function isMultiEventSummarizer(summarizer) {
+    return summarizer.getSummaries !== undefined;
+}
 class EventProcessor {
-    constructor(_config, clientContext, baseHeaders, _contextDeduplicator, _diagnosticsManager, start = true) {
+    constructor(_config, clientContext, baseHeaders, _contextDeduplicator, _diagnosticsManager, start = true, summariesPerContext = false) {
         this._config = _config;
         this._contextDeduplicator = _contextDeduplicator;
         this._diagnosticsManager = _diagnosticsManager;
-        this._summarizer = new EventSummarizer();
         this._queue = [];
         this._lastKnownPastTime = 0;
         this._droppedEvents = 0;
@@ -2468,6 +2572,12 @@ class EventProcessor {
         this._logger = clientContext.basicConfiguration.logger;
         this._eventSender = new EventSender(clientContext, baseHeaders);
         this._contextFilter = new ContextFilter(_config.allAttributesPrivate, _config.privateAttributes.map((ref) => new AttributeReference(ref)));
+        if (summariesPerContext) {
+            this._summarizer = new MultiEventSummarizer(this._contextFilter, this._logger);
+        }
+        else {
+            this._summarizer = new EventSummarizer();
+        }
         if (start) {
             this.start();
         }
@@ -2519,10 +2629,19 @@ class EventProcessor {
         }
         const eventsToFlush = this._queue;
         this._queue = [];
-        const summary = this._summarizer.getSummary();
-        this._summarizer.clearSummary();
-        if (Object.keys(summary.features).length) {
-            eventsToFlush.push(summary);
+        if (isMultiEventSummarizer(this._summarizer)) {
+            const summaries = this._summarizer.getSummaries();
+            summaries.forEach((summary) => {
+                if (Object.keys(summary.features).length) {
+                    eventsToFlush.push(summary);
+                }
+            });
+        }
+        else {
+            const summary = this._summarizer.getSummary();
+            if (Object.keys(summary.features).length) {
+                eventsToFlush.push(summary);
+            }
         }
         if (!eventsToFlush.length) {
             return;
@@ -3113,6 +3232,7 @@ var index = /*#__PURE__*/Object.freeze({
     NullEventProcessor: NullEventProcessor,
     PayloadProcessor: PayloadProcessor,
     PayloadStreamReader: PayloadStreamReader,
+    canonicalize: canonicalize,
     initMetadataFromHeaders: initMetadataFromHeaders,
     isLegacyUser: isLegacyUser,
     isMultiKind: isMultiKind,