@splitsoftware/splitio-commons 2.1.0 → 2.1.1-rc.1

package/cjs/storages/inRedis/SplitsCacheInRedis.js

@@ -67,8 +67,9 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
      * The returned promise is resolved when the operation success
      * or rejected if it fails (e.g., redis operation fails)
      */
-    SplitsCacheInRedis.prototype.addSplit = function (name, split) {
+    SplitsCacheInRedis.prototype.addSplit = function (split) {
         var _this = this;
+        var name = split.name;
         var splitKey = this.keys.buildSplitKey(name);
         return this.redis.get(splitKey).then(function (splitFromStorage) {
             // handling parsing error
@@ -92,18 +93,9 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
             }).then(function () { return _this._updateFlagSets(name, parsedPreviousSplit && parsedPreviousSplit.sets, split.sets); });
         }).then(function () { return true; });
     };
-    /**
-     * Add a list of splits.
-     * The returned promise is resolved when the operation success
-     * or rejected if it fails (e.g., redis operation fails)
-     */
-    SplitsCacheInRedis.prototype.addSplits = function (entries) {
-        var _this = this;
-        return Promise.all(entries.map(function (keyValuePair) { return _this.addSplit(keyValuePair[0], keyValuePair[1]); }));
-    };
     /**
      * Remove a given split.
-     * The returned promise is resolved when the operation success, with 1 or 0 indicating if the split existed or not.
+     * The returned promise is resolved when the operation success, with true or false indicating if the split existed (and was removed) or not.
      * or rejected if it fails (e.g., redis operation fails).
      */
     SplitsCacheInRedis.prototype.removeSplit = function (name) {
@@ -113,18 +105,9 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
                 return _this._decrementCounts(split).then(function () { return _this._updateFlagSets(name, split.sets); });
             }
         }).then(function () {
-            return _this.redis.del(_this.keys.buildSplitKey(name));
+            return _this.redis.del(_this.keys.buildSplitKey(name)).then(function (status) { return status === 1; });
         });
     };
-    /**
-     * Remove a list of splits.
-     * The returned promise is resolved when the operation success,
-     * or rejected if it fails (e.g., redis operation fails).
-     */
-    SplitsCacheInRedis.prototype.removeSplits = function (names) {
-        var _this = this;
-        return Promise.all(names.map(function (name) { return _this.removeSplit(name); }));
-    };
     /**
      * Get split definition or null if it's not defined.
      * Returned promise is rejected if redis operation fails.

package/cjs/storages/pluggable/SplitsCachePluggable.js

@@ -54,8 +54,9 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
      * The returned promise is resolved when the operation success
      * or rejected if it fails (e.g., wrapper operation fails)
      */
-    SplitsCachePluggable.prototype.addSplit = function (name, split) {
+    SplitsCachePluggable.prototype.addSplit = function (split) {
         var _this = this;
+        var name = split.name;
         var splitKey = this.keys.buildSplitKey(name);
         return this.wrapper.get(splitKey).then(function (splitFromStorage) {
             // handling parsing error
@@ -79,15 +80,6 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
             }).then(function () { return _this._updateFlagSets(name, parsedPreviousSplit && parsedPreviousSplit.sets, split.sets); });
         }).then(function () { return true; });
     };
-    /**
-     * Add a list of splits.
-     * The returned promise is resolved when the operation success
-     * or rejected if it fails (e.g., wrapper operation fails)
-     */
-    SplitsCachePluggable.prototype.addSplits = function (entries) {
-        var _this = this;
-        return Promise.all(entries.map(function (keyValuePair) { return _this.addSplit(keyValuePair[0], keyValuePair[1]); }));
-    };
     /**
      * Remove a given split.
      * The returned promise is resolved when the operation success, with a boolean indicating if the split existed or not.
@@ -103,15 +95,6 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
             return _this.wrapper.del(_this.keys.buildSplitKey(name));
         });
     };
-    /**
-     * Remove a list of splits.
-     * The returned promise is resolved when the operation success, with a boolean array indicating if the splits existed or not.
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    SplitsCachePluggable.prototype.removeSplits = function (names) {
-        var _this = this;
-        return Promise.all(names.map(function (name) { return _this.removeSplit(name); }));
-    };
     /**
      * Get split.
      * The returned promise is resolved with the split definition or null if it's not defined,

package/cjs/storages/utils.js

@@ -27,6 +27,7 @@ function impressionsToJSON(impressions, metadata) {
                 c: impression.changeNumber,
                 m: impression.time,
                 pt: impression.pt,
+                properties: impression.properties
             }
         };
         return JSON.stringify(impressionWithMetadata);

package/cjs/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -26,22 +26,21 @@ function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
         if (!loadError && splitsMock) {
             log.debug(constants_3.SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);
             (0, lang_1.forOwn)(splitsMock, function (val, name) {
-                splits.push([
-                    name, {
-                        name: name,
-                        status: 'ACTIVE',
-                        killed: false,
-                        trafficAllocation: 100,
-                        defaultTreatment: constants_1.CONTROL,
-                        conditions: val.conditions || [],
-                        configurations: val.configurations,
-                        trafficTypeName: val.trafficTypeName
-                    }
-                ]);
+                // @ts-ignore Split changeNumber and seed is undefined in localhost mode
+                splits.push({
+                    name: name,
+                    status: 'ACTIVE',
+                    killed: false,
+                    trafficAllocation: 100,
+                    defaultTreatment: constants_1.CONTROL,
+                    conditions: val.conditions || [],
+                    configurations: val.configurations,
+                    trafficTypeName: val.trafficTypeName
+                });
             });
             return Promise.all([
                 splitsCache.clear(),
-                splitsCache.addSplits(splits)
+                splitsCache.update(splits, [], Date.now())
             ]).then(function () {
                 readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED);
                 if (startingUp) {

package/cjs/sync/polling/syncTasks/splitsSyncTask.js

@@ -8,6 +8,6 @@ var splitChangesUpdater_1 = require("../updaters/splitChangesUpdater");
  * Creates a sync task that periodically executes a `splitChangesUpdater` task
  */
 function splitsSyncTaskFactory(fetchSplitChanges, storage, readiness, settings, isClientSide) {
-    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, splitChangesUpdater_1.splitChangesUpdaterFactory)(settings.log, (0, splitChangesFetcher_1.splitChangesFetcherFactory)(fetchSplitChanges), storage.splits, storage.segments, settings.sync.__splitFiltersValidation, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
+    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, splitChangesUpdater_1.splitChangesUpdaterFactory)(settings.log, (0, splitChangesFetcher_1.splitChangesFetcherFactory)(fetchSplitChanges), storage, settings.sync.__splitFiltersValidation, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
 }
 exports.splitsSyncTaskFactory = splitsSyncTaskFactory;

package/cjs/sync/polling/updaters/splitChangesUpdater.js

@@ -62,13 +62,13 @@ function computeSplitsMutation(entries, filters) {
     var segments = new Set();
     var computed = entries.reduce(function (accum, split) {
         if (split.status === 'ACTIVE' && matchFilters(split, filters)) {
-            accum.added.push([split.name, split]);
+            accum.added.push(split);
             parseSegments(split).forEach(function (segmentName) {
                 segments.add(segmentName);
             });
         }
         else {
-            accum.removed.push(split.name);
+            accum.removed.push(split);
         }
         return accum;
     }, { added: [], removed: [], segments: [] });
@@ -90,9 +90,10 @@ exports.computeSplitsMutation = computeSplitsMutation;
  * @param requestTimeoutBeforeReady -  How long the updater will wait for the request to timeout. Default 0, i.e., never timeout.
  * @param retriesOnFailureBeforeReady -  How many retries on `/splitChanges` we the updater do in case of failure or timeout. Default 0, i.e., no retries.
  */
-function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments, splitFiltersValidation, splitsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, isClientSide) {
+function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, splitFiltersValidation, splitsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, isClientSide) {
     if (requestTimeoutBeforeReady === void 0) { requestTimeoutBeforeReady = 0; }
     if (retriesOnFailureBeforeReady === void 0) { retriesOnFailureBeforeReady = 0; }
+    var splits = storage.splits, segments = storage.segments;
     var startingUp = true;
     /** timeout decorator for `splitChangesFetcher` promise  */
     function _promiseDecorator(promise) {
@@ -100,17 +101,6 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments,
             promise = (0, timeout_1.timeout)(requestTimeoutBeforeReady, promise);
         return promise;
     }
-    /** Returns true if at least one split was updated */
-    function isThereUpdate(flagsChange) {
-        var added = flagsChange[1], removed = flagsChange[2];
-        // There is at least one added or modified feature flag
-        if (added && added.some(function (update) { return update; }))
-            return true;
-        // There is at least one removed feature flag
-        if (removed && removed.some(function (update) { return update; }))
-            return true;
-        return false;
-    }
     /**
      * SplitChanges updater returns a promise that resolves with a `false` boolean value if it fails to fetch splits or synchronize them with the storage.
      * Returned promise will not be rejected.
@@ -132,21 +122,17 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments,
                 .then(function (splitChanges) {
                 startingUp = false;
                 var mutation = computeSplitsMutation(splitChanges.splits, splitFiltersValidation);
-                log.debug(constants_2.SYNC_SPLITS_NEW, [mutation.added.length]);
-                log.debug(constants_2.SYNC_SPLITS_REMOVED, [mutation.removed.length]);
-                log.debug(constants_2.SYNC_SPLITS_SEGMENTS, [mutation.segments.length]);
+                log.debug(constants_2.SYNC_SPLITS_UPDATE, [mutation.added.length, mutation.removed.length, mutation.segments.length]);
                 // Write into storage
                 // @TODO call `setChangeNumber` only if the other storage operations have succeeded, in order to keep storage consistency
                 return Promise.all([
-                    // calling first `setChangenumber` method, to perform cache flush if split filter queryString changed
-                    splits.setChangeNumber(splitChanges.till),
-                    splits.addSplits(mutation.added),
-                    splits.removeSplits(mutation.removed),
+                    splits.update(mutation.added, mutation.removed, splitChanges.till),
                     segments.registerSegments(mutation.segments)
-                ]).then(function (flagsChange) {
+                ]).then(function (_a) {
+                    var isThereUpdate = _a[0];
                     if (splitsEventEmitter) {
                         // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
-                        return Promise.resolve(!splitsEventEmitter.splitsArrived || (since !== splitChanges.till && isThereUpdate(flagsChange) && (isClientSide || checkAllSegmentsExist(segments))))
+                        return Promise.resolve(!splitsEventEmitter.splitsArrived || (since !== splitChanges.till && isThereUpdate && (isClientSide || checkAllSegmentsExist(segments))))
                             .catch(function () { return false; } /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
                             .then(function (emitSplitsArrivedEvent) {
                             // emit SDK events

package/cjs/sync/submitters/impressionsSubmitter.js

@@ -22,8 +22,9 @@ function fromImpressionsCollector(sendLabels, data) {
                     m: entry.time,
                     c: entry.changeNumber,
                     r: sendLabels ? entry.label : undefined,
-                    b: entry.bucketingKey ? entry.bucketingKey : undefined,
-                    pt: entry.pt ? entry.pt : undefined // Previous time
+                    b: entry.bucketingKey,
+                    pt: entry.pt,
+                    properties: entry.properties // Properties
                 };
                 return keyImpression;
             })

package/cjs/trackers/strategy/strategyOptimized.js

@@ -12,6 +12,9 @@ var time_1 = require("../../utils/time");
 function strategyOptimizedFactory(impressionsObserver, impressionCounts) {
     return {
         process: function (impression) {
+            // DEBUG mode without previous time, for impressions with properties
+            if (impression.properties)
+                return true;
             impression.pt = impressionsObserver.testAndSet(impression);
             var now = Date.now();
             // Increments impression counter per featureName

package/cjs/utils/inputValidation/eventProperties.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateEventProperties = void 0;
+exports.validateEvaluationOptions = exports.validateEventProperties = void 0;
 var lang_1 = require("../lang");
 var objectAssign_1 = require("../lang/objectAssign");
 var constants_1 = require("../../logger/constants");
@@ -61,3 +61,14 @@ function validateEventProperties(log, maybeProperties, method) {
     return output;
 }
 exports.validateEventProperties = validateEventProperties;
+function validateEvaluationOptions(log, maybeOptions, method) {
+    if ((0, lang_1.isObject)(maybeOptions)) {
+        var properties = validateEventProperties(log, maybeOptions.properties, method).properties;
+        return properties && Object.keys(properties).length > 0 ? { properties: properties } : undefined;
+    }
+    else if (maybeOptions) {
+        log.error(constants_1.ERROR_NOT_PLAIN_OBJECT, [method, 'evaluation options']);
+    }
+    return undefined;
+}
+exports.validateEvaluationOptions = validateEvaluationOptions;

package/cjs/utils/inputValidation/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validatePreloadedData = exports.validateTrafficTypeExistence = exports.validateSplitExistence = exports.validateIfOperational = exports.validateIfNotDestroyed = exports.validateTrafficType = exports.validateSplits = exports.validateSplit = exports.validateKey = exports.validateEventProperties = exports.validateEventValue = exports.validateEvent = exports.validateAttributes = exports.releaseApiKey = exports.validateAndTrackApiKey = exports.validateApiKey = void 0;
+exports.validateEvaluationOptions = exports.validatePreloadedData = exports.validateTrafficTypeExistence = exports.validateSplitExistence = exports.validateIfOperational = exports.validateIfNotDestroyed = exports.validateTrafficType = exports.validateSplits = exports.validateSplit = exports.validateKey = exports.validateEventProperties = exports.validateEventValue = exports.validateEvent = exports.validateAttributes = exports.releaseApiKey = exports.validateAndTrackApiKey = exports.validateApiKey = void 0;
 var apiKey_1 = require("./apiKey");
 Object.defineProperty(exports, "validateApiKey", { enumerable: true, get: function () { return apiKey_1.validateApiKey; } });
 Object.defineProperty(exports, "validateAndTrackApiKey", { enumerable: true, get: function () { return apiKey_1.validateAndTrackApiKey; } });
@@ -30,3 +30,5 @@ var trafficTypeExistence_1 = require("./trafficTypeExistence");
 Object.defineProperty(exports, "validateTrafficTypeExistence", { enumerable: true, get: function () { return trafficTypeExistence_1.validateTrafficTypeExistence; } });
 var preloadedData_1 = require("./preloadedData");
 Object.defineProperty(exports, "validatePreloadedData", { enumerable: true, get: function () { return preloadedData_1.validatePreloadedData; } });
+var eventProperties_2 = require("./eventProperties");
+Object.defineProperty(exports, "validateEvaluationOptions", { enumerable: true, get: function () { return eventProperties_2.validateEvaluationOptions; } });

package/esm/logger/constants.js

@@ -20,9 +20,7 @@ export var RETRIEVE_CLIENT_EXISTING = 28;
 export var RETRIEVE_MANAGER = 29;
 export var SYNC_OFFLINE_DATA = 30;
 export var SYNC_SPLITS_FETCH = 31;
-export var SYNC_SPLITS_NEW = 32;
-export var SYNC_SPLITS_REMOVED = 33;
-export var SYNC_SPLITS_SEGMENTS = 34;
+export var SYNC_SPLITS_UPDATE = 32;
 export var STREAMING_NEW_MESSAGE = 35;
 export var SYNC_TASK_START = 36;
 export var SYNC_TASK_EXECUTE = 37;

package/esm/logger/messages/debug.js

@@ -20,9 +20,7 @@ export var codesDebug = codesInfo.concat([
     // synchronizer
     [c.SYNC_OFFLINE_DATA, c.LOG_PREFIX_SYNC_OFFLINE + 'Feature flags data: \n%s'],
     [c.SYNC_SPLITS_FETCH, c.LOG_PREFIX_SYNC_SPLITS + 'Spin up feature flags update using since = %s'],
-    [c.SYNC_SPLITS_NEW, c.LOG_PREFIX_SYNC_SPLITS + 'New feature flags %s'],
-    [c.SYNC_SPLITS_REMOVED, c.LOG_PREFIX_SYNC_SPLITS + 'Removed feature flags %s'],
-    [c.SYNC_SPLITS_SEGMENTS, c.LOG_PREFIX_SYNC_SPLITS + 'Segment names collected %s'],
+    [c.SYNC_SPLITS_UPDATE, c.LOG_PREFIX_SYNC_SPLITS + 'New feature flags %s. Removed feature flags %s. Segment names collected %s'],
     [c.STREAMING_NEW_MESSAGE, c.LOG_PREFIX_SYNC_STREAMING + 'New SSE message received, with data: %s.'],
     [c.SYNC_TASK_START, c.LOG_PREFIX_SYNC + ': Starting %s. Running each %s millis'],
     [c.SYNC_TASK_EXECUTE, c.LOG_PREFIX_SYNC + ': Running %s'],

package/esm/logger/messages/error.js

@@ -20,7 +20,7 @@ export var codesError = [
     // input validation
     [c.ERROR_EVENT_TYPE_FORMAT, '%s: you passed "%s", event_type must adhere to the regular expression /^[a-zA-Z0-9][-_.:a-zA-Z0-9]{0,79}$/g. This means an event_type must be alphanumeric, cannot be more than 80 characters long, and can only include a dash, underscore, period, or colon as separators of alphanumeric characters.'],
     [c.ERROR_NOT_PLAIN_OBJECT, '%s: %s must be a plain object.'],
-    [c.ERROR_SIZE_EXCEEDED, '%s: the maximum size allowed for the properties is 32768 bytes, which was exceeded. Event not queued.'],
+    [c.ERROR_SIZE_EXCEEDED, '%s: the maximum size allowed for the properties is 32768 bytes, which was exceeded.'],
     [c.ERROR_NOT_FINITE, '%s: value must be a finite number.'],
     [c.ERROR_NULL, '%s: you passed a null or undefined %s. It must be a non-empty string.'],
     [c.ERROR_TOO_LONG, '%s: %s too long. It must have 250 characters or less.'],

package/esm/logger/messages/warn.js

@@ -17,7 +17,7 @@ export var codesWarn = codesError.concat([
     [c.CLIENT_NO_LISTENER, 'No listeners for SDK Readiness detected. Incorrect control treatments could have been logged if you called getTreatment/s while the SDK was not yet ready.'],
     // input validation
     [c.WARN_SETTING_NULL, '%s: Property "%s" is of invalid type. Setting value to null.'],
-    [c.WARN_TRIMMING_PROPERTIES, '%s: Event has more than 300 properties. Some of them will be trimmed when processed.'],
+    [c.WARN_TRIMMING_PROPERTIES, '%s: more than 300 properties were provided. Some of them will be trimmed when processed.'],
     [c.WARN_CONVERTING, '%s: %s "%s" is not of type string, converting.'],
     [c.WARN_TRIMMING, '%s: %s "%s" has extra whitespace, trimming.'],
     [c.WARN_NOT_EXISTENT_SPLIT, '%s: feature flag "%s" does not exist in this environment. Please double check what feature flags exist in the Split user interface.'],

package/esm/sdkClient/client.js

@@ -15,6 +15,14 @@ function treatmentsNotReady(featureFlagNames) {
     });
     return evaluations;
 }
+function stringify(options) {
+    if (options && options.properties) {
+        try {
+            return JSON.stringify(options.properties);
+        }
+        catch ( /* JSON.stringify should never throw with validated options, but handling just in case */_a) { /* JSON.stringify should never throw with validated options, but handling just in case */ }
+    }
+}
 /**
  * Creator of base client with getTreatments and track methods.
  */
@@ -22,13 +30,13 @@ export function clientFactory(params) {
     var readinessManager = params.sdkReadinessManager.readinessManager, storage = params.storage, settings = params.settings, impressionsTracker = params.impressionsTracker, eventTracker = params.eventTracker, telemetryTracker = params.telemetryTracker;
     var log = settings.log, mode = settings.mode;
     var isAsync = isConsumerMode(mode);
-    function getTreatment(key, featureFlagName, attributes, withConfig, methodName) {
+    function getTreatment(key, featureFlagName, attributes, options, withConfig, methodName) {
         if (withConfig === void 0) { withConfig = false; }
         if (methodName === void 0) { methodName = GET_TREATMENT; }
         var stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);
         var wrapUp = function (evaluationResult) {
             var queue = [];
-            var treatment = processEvaluation(evaluationResult, featureFlagName, key, attributes, withConfig, methodName, queue);
+            var treatment = processEvaluation(evaluationResult, featureFlagName, key, stringify(options), withConfig, methodName, queue);
             impressionsTracker.track(queue, attributes);
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
             return treatment;
@@ -40,18 +48,19 @@ export function clientFactory(params) {
                 treatmentNotReady;
         return thenable(evaluation) ? evaluation.then(function (res) { return wrapUp(res); }) : wrapUp(evaluation);
     }
-    function getTreatmentWithConfig(key, featureFlagName, attributes) {
-        return getTreatment(key, featureFlagName, attributes, true, GET_TREATMENT_WITH_CONFIG);
+    function getTreatmentWithConfig(key, featureFlagName, attributes, options) {
+        return getTreatment(key, featureFlagName, attributes, options, true, GET_TREATMENT_WITH_CONFIG);
     }
-    function getTreatments(key, featureFlagNames, attributes, withConfig, methodName) {
+    function getTreatments(key, featureFlagNames, attributes, options, withConfig, methodName) {
         if (withConfig === void 0) { withConfig = false; }
         if (methodName === void 0) { methodName = GET_TREATMENTS; }
         var stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENTS_WITH_CONFIG : TREATMENTS);
         var wrapUp = function (evaluationResults) {
             var queue = [];
             var treatments = {};
+            var properties = stringify(options);
             Object.keys(evaluationResults).forEach(function (featureFlagName) {
-                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, attributes, withConfig, methodName, queue);
+                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, properties, withConfig, methodName, queue);
             });
             impressionsTracker.track(queue, attributes);
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
@@ -64,10 +73,10 @@ export function clientFactory(params) {
                 treatmentsNotReady(featureFlagNames);
         return thenable(evaluations) ? evaluations.then(function (res) { return wrapUp(res); }) : wrapUp(evaluations);
     }
-    function getTreatmentsWithConfig(key, featureFlagNames, attributes) {
-        return getTreatments(key, featureFlagNames, attributes, true, GET_TREATMENTS_WITH_CONFIG);
+    function getTreatmentsWithConfig(key, featureFlagNames, attributes, options) {
+        return getTreatments(key, featureFlagNames, attributes, options, true, GET_TREATMENTS_WITH_CONFIG);
     }
-    function getTreatmentsByFlagSets(key, flagSetNames, attributes, withConfig, method, methodName) {
+    function getTreatmentsByFlagSets(key, flagSetNames, attributes, options, withConfig, method, methodName) {
         if (withConfig === void 0) { withConfig = false; }
         if (method === void 0) { method = TREATMENTS_BY_FLAGSETS; }
         if (methodName === void 0) { methodName = GET_TREATMENTS_BY_FLAG_SETS; }
@@ -75,9 +84,9 @@ export function clientFactory(params) {
         var wrapUp = function (evaluationResults) {
             var queue = [];
             var treatments = {};
-            var evaluations = evaluationResults;
-            Object.keys(evaluations).forEach(function (featureFlagName) {
-                treatments[featureFlagName] = processEvaluation(evaluations[featureFlagName], featureFlagName, key, attributes, withConfig, methodName, queue);
+            var properties = stringify(options);
+            Object.keys(evaluationResults).forEach(function (featureFlagName) {
+                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, properties, withConfig, methodName, queue);
             });
             impressionsTracker.track(queue, attributes);
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
@@ -90,17 +99,17 @@ export function clientFactory(params) {
                 {};
         return thenable(evaluations) ? evaluations.then(function (res) { return wrapUp(res); }) : wrapUp(evaluations);
     }
-    function getTreatmentsWithConfigByFlagSets(key, flagSetNames, attributes) {
-        return getTreatmentsByFlagSets(key, flagSetNames, attributes, true, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS);
+    function getTreatmentsWithConfigByFlagSets(key, flagSetNames, attributes, options) {
+        return getTreatmentsByFlagSets(key, flagSetNames, attributes, options, true, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS);
     }
-    function getTreatmentsByFlagSet(key, flagSetName, attributes) {
-        return getTreatmentsByFlagSets(key, [flagSetName], attributes, false, TREATMENTS_BY_FLAGSET, GET_TREATMENTS_BY_FLAG_SET);
+    function getTreatmentsByFlagSet(key, flagSetName, attributes, options) {
+        return getTreatmentsByFlagSets(key, [flagSetName], attributes, options, false, TREATMENTS_BY_FLAGSET, GET_TREATMENTS_BY_FLAG_SET);
     }
-    function getTreatmentsWithConfigByFlagSet(key, flagSetName, attributes) {
-        return getTreatmentsByFlagSets(key, [flagSetName], attributes, true, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET);
+    function getTreatmentsWithConfigByFlagSet(key, flagSetName, attributes, options) {
+        return getTreatmentsByFlagSets(key, [flagSetName], attributes, options, true, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET);
     }
     // Internal function
-    function processEvaluation(evaluation, featureFlagName, key, attributes, withConfig, invokingMethodName, queue) {
+    function processEvaluation(evaluation, featureFlagName, key, properties, withConfig, invokingMethodName, queue) {
         var matchingKey = getMatching(key);
         var bucketingKey = getBucketing(key);
         var treatment = evaluation.treatment, label = evaluation.label, changeNumber = evaluation.changeNumber, _a = evaluation.config, config = _a === void 0 ? null : _a, impressionsDisabled = evaluation.impressionsDisabled;
@@ -116,6 +125,7 @@ export function clientFactory(params) {
                     bucketingKey: bucketingKey,
                     label: label,
                     changeNumber: changeNumber,
+                    properties: properties
                 },
                 disabled: impressionsDisabled
             });

package/esm/sdkClient/clientAttributesDecoration.js

@@ -15,40 +15,35 @@ export function clientAttributesDecoration(log, client) {
     var clientGetTreatmentsWithConfigByFlagSets = client.getTreatmentsWithConfigByFlagSets;
     var clientGetTreatmentsByFlagSet = client.getTreatmentsByFlagSet;
     var clientGetTreatmentsWithConfigByFlagSet = client.getTreatmentsWithConfigByFlagSet;
-    var clientTrack = client.track;
-    function getTreatment(maybeKey, maybeFeatureFlagName, maybeAttributes) {
-        return clientGetTreatment(maybeKey, maybeFeatureFlagName, combineAttributes(maybeAttributes));
+    function getTreatment(maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions) {
+        return clientGetTreatment(maybeKey, maybeFeatureFlagName, combineAttributes(maybeAttributes), maybeOptions);
     }
-    function getTreatmentWithConfig(maybeKey, maybeFeatureFlagName, maybeAttributes) {
-        return clientGetTreatmentWithConfig(maybeKey, maybeFeatureFlagName, combineAttributes(maybeAttributes));
+    function getTreatmentWithConfig(maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions) {
+        return clientGetTreatmentWithConfig(maybeKey, maybeFeatureFlagName, combineAttributes(maybeAttributes), maybeOptions);
     }
-    function getTreatments(maybeKey, maybeFeatureFlagNames, maybeAttributes) {
-        return clientGetTreatments(maybeKey, maybeFeatureFlagNames, combineAttributes(maybeAttributes));
+    function getTreatments(maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions) {
+        return clientGetTreatments(maybeKey, maybeFeatureFlagNames, combineAttributes(maybeAttributes), maybeOptions);
     }
-    function getTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, maybeAttributes) {
-        return clientGetTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, combineAttributes(maybeAttributes));
+    function getTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions) {
+        return clientGetTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, combineAttributes(maybeAttributes), maybeOptions);
     }
-    function getTreatmentsByFlagSets(maybeKey, maybeFlagSets, maybeAttributes) {
-        return clientGetTreatmentsByFlagSets(maybeKey, maybeFlagSets, combineAttributes(maybeAttributes));
+    function getTreatmentsByFlagSets(maybeKey, maybeFlagSets, maybeAttributes, maybeOptions) {
+        return clientGetTreatmentsByFlagSets(maybeKey, maybeFlagSets, combineAttributes(maybeAttributes), maybeOptions);
     }
-    function getTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, maybeAttributes) {
-        return clientGetTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, combineAttributes(maybeAttributes));
+    function getTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, maybeAttributes, maybeOptions) {
+        return clientGetTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, combineAttributes(maybeAttributes), maybeOptions);
     }
-    function getTreatmentsByFlagSet(maybeKey, maybeFlagSet, maybeAttributes) {
-        return clientGetTreatmentsByFlagSet(maybeKey, maybeFlagSet, combineAttributes(maybeAttributes));
+    function getTreatmentsByFlagSet(maybeKey, maybeFlagSet, maybeAttributes, maybeOptions) {
+        return clientGetTreatmentsByFlagSet(maybeKey, maybeFlagSet, combineAttributes(maybeAttributes), maybeOptions);
     }
-    function getTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, maybeAttributes) {
-        return clientGetTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, combineAttributes(maybeAttributes));
-    }
-    function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
-        return clientTrack(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties);
+    function getTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, maybeAttributes, maybeOptions) {
+        return clientGetTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, combineAttributes(maybeAttributes), maybeOptions);
     }
     function combineAttributes(maybeAttributes) {
         var storedAttributes = attributeStorage.getAll();
-        if (Object.keys(storedAttributes).length > 0) {
-            return objectAssign({}, storedAttributes, maybeAttributes);
-        }
-        return maybeAttributes;
+        return Object.keys(storedAttributes).length > 0 ?
+            objectAssign({}, storedAttributes, maybeAttributes) :
+            maybeAttributes;
     }
     return objectAssign(client, {
         getTreatment: getTreatment,
@@ -59,7 +54,6 @@ export function clientAttributesDecoration(log, client) {
         getTreatmentsWithConfigByFlagSets: getTreatmentsWithConfigByFlagSets,
         getTreatmentsByFlagSet: getTreatmentsByFlagSet,
         getTreatmentsWithConfigByFlagSet: getTreatmentsWithConfigByFlagSet,
-        track: track,
         /**
          * Add an attribute to client's in memory attributes storage
          *