[Impressions toggle] Add trackImpressions property

src/dtos/types.ts

@@ -208,7 +208,8 @@ export interface ISplit {
   configurations?: {
     [treatmentName: string]: string
   },
-  sets?: string[]
+  sets?: string[],
+  trackImpressions?: boolean
 }
 
 // Split definition used in offline mode

src/evaluator/index.ts

@@ -156,12 +156,14 @@ function getEvaluation(
       return evaluation.then(result => {
         result.changeNumber = split.getChangeNumber();
         result.config = splitJSON.configurations && splitJSON.configurations[result.treatment] || null;
+        result.track = splitJSON.trackImpressions;
 
         return result;
       });
     } else {
       evaluation.changeNumber = split.getChangeNumber(); // Always sync and optional
       evaluation.config = splitJSON.configurations && splitJSON.configurations[evaluation.treatment] || null;
+      evaluation.track = splitJSON.trackImpressions;
     }
   }
 

src/evaluator/types.ts

@@ -25,7 +25,7 @@ export interface IEvaluation {
   config?: string | null
 }
 
-export type IEvaluationResult = IEvaluation & { treatment: string }
+export type IEvaluationResult = IEvaluation & { treatment: string; track?: boolean }
 
 export type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
 

src/sdkClient/client.ts

@@ -11,6 +11,7 @@ import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { Method } from '../sync/submitters/types';
+import { ImpressionDecorated } from '../trackers/types';
 
 const treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
 
@@ -34,11 +35,11 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);
 
     const wrapUp = (evaluationResult: IEvaluationResult) => {
-      const queue: SplitIO.ImpressionDTO[] = [];
+      const queue: ImpressionDecorated[] = [];
       const treatment = processEvaluation(evaluationResult, featureFlagName, key, attributes, withConfig, methodName, queue);
       impressionsTracker.track(queue, attributes);
 
-      stopTelemetryTracker(queue[0] && queue[0].label);
+      stopTelemetryTracker(queue[0] && queue[0].imp.label);
       return treatment;
     };
 
@@ -59,14 +60,14 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENTS_WITH_CONFIG : TREATMENTS);
 
     const wrapUp = (evaluationResults: Record<string, IEvaluationResult>) => {
-      const queue: SplitIO.ImpressionDTO[] = [];
+      const queue: ImpressionDecorated[] = [];
       const treatments: Record<string, SplitIO.Treatment | SplitIO.TreatmentWithConfig> = {};
       Object.keys(evaluationResults).forEach(featureFlagName => {
         treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, attributes, withConfig, methodName, queue);
       });
       impressionsTracker.track(queue, attributes);
 
-      stopTelemetryTracker(queue[0] && queue[0].label);
+      stopTelemetryTracker(queue[0] && queue[0].imp.label);
       return treatments;
     };
 
@@ -87,15 +88,15 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     const stopTelemetryTracker = telemetryTracker.trackEval(method);
 
     const wrapUp = (evaluationResults: Record<string, IEvaluationResult>) => {
-      const queue: SplitIO.ImpressionDTO[] = [];
+      const queue: ImpressionDecorated[] = [];
       const treatments: Record<string, SplitIO.Treatment | SplitIO.TreatmentWithConfig> = {};
       const evaluations = evaluationResults;
       Object.keys(evaluations).forEach(featureFlagName => {
         treatments[featureFlagName] = processEvaluation(evaluations[featureFlagName], featureFlagName, key, attributes, withConfig, methodName, queue);
       });
       impressionsTracker.track(queue, attributes);
 
-      stopTelemetryTracker(queue[0] && queue[0].label);
+      stopTelemetryTracker(queue[0] && queue[0].imp.label);
       return treatments;
     };
 
@@ -128,24 +129,27 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     attributes: SplitIO.Attributes | undefined,
     withConfig: boolean,
     invokingMethodName: string,
-    queue: SplitIO.ImpressionDTO[]
+    queue: ImpressionDecorated[]
   ): SplitIO.Treatment | SplitIO.TreatmentWithConfig {
     const matchingKey = getMatching(key);
     const bucketingKey = getBucketing(key);
 
-    const { treatment, label, changeNumber, config = null } = evaluation;
+    const { treatment, label, changeNumber, config = null, track } = evaluation;
     log.info(IMPRESSION, [featureFlagName, matchingKey, treatment, label]);
 
     if (validateSplitExistence(log, readinessManager, featureFlagName, label, invokingMethodName)) {
       log.info(IMPRESSION_QUEUEING);
       queue.push({
-        feature: featureFlagName,
-        keyName: matchingKey,
-        treatment,
-        time: Date.now(),
-        bucketingKey,
-        label,
-        changeNumber: changeNumber as number
+        imp: {
+          feature: featureFlagName,
+          keyName: matchingKey,
+          treatment,
+          time: Date.now(),
+          bucketingKey,
+          label,
+          changeNumber: changeNumber as number,
+        },
+        track
       });
     }
 

src/trackers/__tests__/impressionsTracker.spec.ts

@@ -70,7 +70,7 @@ describe('Impressions Tracker', () => {
 
     expect(fakeImpressionsCache.track).not.toBeCalled(); // cache method should not be called by just creating a tracker
 
-    tracker.track([imp1, imp2, imp3]);
+    tracker.track([{ imp: imp1 }, { imp: imp2 }, { imp: imp3 }]);
 
     expect(fakeImpressionsCache.track.mock.calls[0][0]).toEqual([imp1, imp2, imp3]); // Should call the storage track method once we invoke .track() method, passing queued params in a sequence.
   });
@@ -93,7 +93,7 @@ describe('Impressions Tracker', () => {
     expect(fakeIntegrationsManager.handleImpression).not.toBeCalled(); // The integrations manager handleImpression method should not be invoked if we haven't tracked impressions.
 
     // We signal that we actually want to track the queued impressions.
-    tracker.track([fakeImpression, fakeImpression2], fakeAttributes);
+    tracker.track([{ imp: fakeImpression }, { imp: fakeImpression2 }], fakeAttributes);
 
     expect(fakeImpressionsCache.track.mock.calls[0][0]).toEqual([fakeImpression, fakeImpression2]); // Even with a listener, impression should be sent to the cache
     expect(fakeListener.logImpression).not.toBeCalled(); // The listener should not be executed synchronously.
@@ -157,7 +157,7 @@ describe('Impressions Tracker', () => {
     expect(fakeImpressionsCache.track).not.toBeCalled(); // storage method should not be called until impressions are tracked.
 
     trackers.forEach(tracker => {
-      tracker.track([impression, impression2, impression3]);
+      tracker.track([{ imp: impression }, { imp: impression2 }, { imp: impression3 }]);
 
       const lastArgs = fakeImpressionsCache.track.mock.calls[fakeImpressionsCache.track.mock.calls.length - 1];
 
@@ -182,7 +182,7 @@ describe('Impressions Tracker', () => {
 
     expect(fakeImpressionsCache.track).not.toBeCalled(); // cache method should not be called by just creating a tracker
 
-    tracker.track([impression, impression2, impression3]);
+    tracker.track([{ imp: impression }, { imp: impression2 }, { imp: impression3 }]);
 
     const lastArgs = fakeImpressionsCache.track.mock.calls[fakeImpressionsCache.track.mock.calls.length - 1];
 
@@ -203,19 +203,19 @@ describe('Impressions Tracker', () => {
 
     const tracker = impressionsTrackerFactory(settings, fakeImpressionsCache, strategy, fakeWhenInit);
 
-    tracker.track([impression]);
+    tracker.track([{ imp: impression }]);
     expect(fakeImpressionsCache.track).toBeCalledTimes(1); // impression should be tracked if userConsent is undefined
 
     settings.userConsent = 'UNKNOWN';
-    tracker.track([impression]);
+    tracker.track([{ imp: impression }]);
     expect(fakeImpressionsCache.track).toBeCalledTimes(2); // impression should be tracked if userConsent is unknown
 
     settings.userConsent = 'GRANTED';
-    tracker.track([impression]);
+    tracker.track([{ imp: impression }]);
     expect(fakeImpressionsCache.track).toBeCalledTimes(3); // impression should be tracked if userConsent is granted
 
     settings.userConsent = 'DECLINED';
-    tracker.track([impression]);
+    tracker.track([{ imp: impression }]);
     expect(fakeImpressionsCache.track).toBeCalledTimes(3); // impression should not be tracked if userConsent is declined
   });
 

src/trackers/impressionsTracker.ts

@@ -1,7 +1,7 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { IImpressionsCacheBase, ITelemetryCacheSync, ITelemetryCacheAsync } from '../storages/types';
-import { IImpressionsHandler, IImpressionsTracker, IStrategy } from './types';
+import { IImpressionsHandler, IImpressionsTracker, ImpressionDecorated, IStrategy } from './types';
 import { ISettings } from '../types';
 import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants';
 import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
@@ -28,9 +28,10 @@ export function impressionsTrackerFactory(
   const { log, impressionListener, runtime: { ip, hostname }, version } = settings;
 
   return {
-    track(impressions: SplitIO.ImpressionDTO[], attributes?: SplitIO.Attributes) {
+    track(imps: ImpressionDecorated[], attributes?: SplitIO.Attributes) {
       if (settings.userConsent === CONSENT_DECLINED) return;
 
+      const impressions = imps.map((item) => item.imp);
       const impressionsCount = impressions.length;
       const { impressionsToStore, impressionsToListener, deduped } = strategy.process(impressions);
 

src/trackers/types.ts

@@ -17,8 +17,19 @@ export interface IImpressionsHandler {
   handleImpression(impressionData: SplitIO.ImpressionData): any
 }
 
+export type ImpressionDecorated = {
+  /**
+   * Impression DTO
+   */
+  imp: SplitIO.ImpressionDTO,
+  /**
+   * Whether the impression should be tracked or not
+   */
+  track?: boolean
+};
+
 export interface IImpressionsTracker {
-  track(impressions: SplitIO.ImpressionDTO[], attributes?: SplitIO.Attributes): void
+  track(impressions: ImpressionDecorated[], attributes?: SplitIO.Attributes): void
 }
 
 /** Telemetry tracker */