@splitsoftware/splitio-commons 1.6.2-rc.13 → 1.6.2-rc.14

package/esm/storages/pluggable/inMemoryWrapper.js

@@ -34,29 +34,31 @@ export function inMemoryWrapperFactory(connDelay) {
         getKeysByPrefix: function (prefix) {
             return Promise.resolve(Object.keys(_cache).filter(function (key) { return startsWith(key, prefix); }));
         },
-        incr: function (key) {
+        incr: function (key, increment) {
+            if (increment === void 0) { increment = 1; }
             if (key in _cache) {
-                var count = toNumber(_cache[key]) + 1;
+                var count = toNumber(_cache[key]) + increment;
                 if (isNaN(count))
                     return Promise.reject('Given key is not a number');
                 _cache[key] = count + '';
                 return Promise.resolve(count);
             }
             else {
-                _cache[key] = '1';
+                _cache[key] = '' + increment;
                 return Promise.resolve(1);
             }
         },
-        decr: function (key) {
+        decr: function (key, decrement) {
+            if (decrement === void 0) { decrement = 1; }
             if (key in _cache) {
-                var count = toNumber(_cache[key]) - 1;
+                var count = toNumber(_cache[key]) - decrement;
                 if (isNaN(count))
                     return Promise.reject('Given key is not a number');
                 _cache[key] = count + '';
                 return Promise.resolve(count);
             }
             else {
-                _cache[key] = '-1';
+                _cache[key] = '-' + decrement;
                 return Promise.resolve(-1);
             }
         },

package/esm/storages/pluggable/index.js

@@ -17,7 +17,7 @@ import { ImpressionCountsCachePluggable } from './ImpressionCountsCachePluggable
 import { UniqueKeysCachePluggable } from './UniqueKeysCachePluggable';
 import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
-import { metadataBuilder } from '../metadataBuilder';
+import { metadataBuilder } from '../utils';
 var NO_VALID_WRAPPER = 'Expecting pluggable storage `wrapper` in options, but no valid wrapper instance was provided.';
 var NO_VALID_WRAPPER_INTERFACE = 'The provided wrapper instance doesn’t follow the expected interface. Check our docs.';
 /**

package/esm/storages/utils.js

@@ -0,0 +1,65 @@
+// Shared utils for Redis and Pluggable storage
+import { UNKNOWN } from '../utils/constants';
+import { MAX_LATENCY_BUCKET_COUNT } from './inMemory/TelemetryCacheInMemory';
+import { METHOD_NAMES } from './KeyBuilderSS';
+export function metadataBuilder(settings) {
+    return {
+        s: settings.version,
+        i: settings.runtime.ip || UNKNOWN,
+        n: settings.runtime.hostname || UNKNOWN,
+    };
+}
+// Converts impressions to be stored in Redis or pluggable storage.
+export function impressionsToJSON(impressions, metadata) {
+    return impressions.map(function (impression) {
+        var impressionWithMetadata = {
+            m: metadata,
+            i: {
+                k: impression.keyName,
+                b: impression.bucketingKey,
+                f: impression.feature,
+                t: impression.treatment,
+                r: impression.label,
+                c: impression.changeNumber,
+                m: impression.time,
+                pt: impression.pt,
+            }
+        };
+        return JSON.stringify(impressionWithMetadata);
+    });
+}
+// Utilities used by TelemetryCacheInRedis and TelemetryCachePluggable
+var REVERSE_METHOD_NAMES = Object.keys(METHOD_NAMES).reduce(function (acc, key) {
+    acc[METHOD_NAMES[key]] = key;
+    return acc;
+}, {});
+export function parseMetadata(field) {
+    var parts = field.split('/');
+    if (parts.length !== 3)
+        return "invalid subsection count. Expected 3, got: " + parts.length;
+    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */;
+    return [JSON.stringify({ s: s, n: n, i: i })];
+}
+export function parseExceptionField(field) {
+    var parts = field.split('/');
+    if (parts.length !== 4)
+        return "invalid subsection count. Expected 4, got: " + parts.length;
+    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */, m = parts[3];
+    var method = REVERSE_METHOD_NAMES[m];
+    if (!method)
+        return "unknown method '" + m + "'";
+    return [JSON.stringify({ s: s, n: n, i: i }), method];
+}
+export function parseLatencyField(field) {
+    var parts = field.split('/');
+    if (parts.length !== 5)
+        return "invalid subsection count. Expected 5, got: " + parts.length;
+    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */, m = parts[3], b = parts[4];
+    var method = REVERSE_METHOD_NAMES[m];
+    if (!method)
+        return "unknown method '" + m + "'";
+    var bucket = parseInt(b);
+    if (isNaN(bucket) || bucket >= MAX_LATENCY_BUCKET_COUNT)
+        return "invalid bucket. Expected a number between 0 and " + (MAX_LATENCY_BUCKET_COUNT - 1) + ", got: " + b;
+    return [JSON.stringify({ s: s, n: n, i: i }), method, bucket];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.6.2-rc.13",
+  "version": "1.6.2-rc.14",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/services/splitApi.ts

@@ -106,7 +106,7 @@ export function splitApiFactory(
       const url = `${urls.events}/testImpressions/count`;
       return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
     },
-    
+
     /**
      * Post unique keys for client side.
      *
@@ -117,7 +117,7 @@ export function splitApiFactory(
       const url = `${urls.telemetry}/v1/keys/cs`;
       return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY));
     },
-    
+
     /**
      * Post unique keys for server side.
      *

package/src/storages/KeyBuilderSS.ts

@@ -1,9 +1,8 @@
 import { KeyBuilder } from './KeyBuilder';
 import { IMetadata } from '../dtos/types';
 import { Method } from '../sync/submitters/types';
-import { MAX_LATENCY_BUCKET_COUNT } from './inMemory/TelemetryCacheInMemory';
 
-const METHOD_NAMES: Record<Method, string> = {
+export const METHOD_NAMES: Record<Method, string> = {
   t: 'treatment',
   ts: 'treatments',
   tc: 'treatmentWithConfig',
@@ -37,7 +36,7 @@ export class KeyBuilderSS extends KeyBuilder {
   buildImpressionsCountKey() {
     return `${this.prefix}.impressions.count`;
   }
-  
+
   buildUniqueKeysKey() {
     return `${this.prefix}.uniquekeys`;
   }
@@ -65,44 +64,3 @@ export class KeyBuilderSS extends KeyBuilder {
   }
 
 }
-
-// Used by consumer methods of TelemetryCacheInRedis and TelemetryCachePluggable
-
-const REVERSE_METHOD_NAMES = Object.keys(METHOD_NAMES).reduce((acc, key) => {
-  acc[METHOD_NAMES[key as Method]] = key as Method;
-  return acc;
-}, {} as Record<string, Method>);
-
-
-export function parseMetadata(field: string): [metadata: string] | string {
-  const parts = field.split('/');
-  if (parts.length !== 3) return `invalid subsection count. Expected 3, got: ${parts.length}`;
-
-  const [s /* metadata.s */, n /* metadata.n */, i /* metadata.i */] = parts;
-  return [JSON.stringify({ s, n, i })];
-}
-
-export function parseExceptionField(field: string): [metadata: string, method: Method] | string {
-  const parts = field.split('/');
-  if (parts.length !== 4) return `invalid subsection count. Expected 4, got: ${parts.length}`;
-
-  const [s /* metadata.s */, n /* metadata.n */, i /* metadata.i */, m] = parts;
-  const method = REVERSE_METHOD_NAMES[m];
-  if (!method) return `unknown method '${m}'`;
-
-  return [JSON.stringify({ s, n, i }), method];
-}
-
-export function parseLatencyField(field: string): [metadata: string, method: Method, bucket: number] | string {
-  const parts = field.split('/');
-  if (parts.length !== 5) return `invalid subsection count. Expected 5, got: ${parts.length}`;
-
-  const [s /* metadata.s */, n /* metadata.n */, i /* metadata.i */, m, b] = parts;
-  const method = REVERSE_METHOD_NAMES[m];
-  if (!method) return `unknown method '${m}'`;
-
-  const bucket = parseInt(b);
-  if (isNaN(bucket) || bucket >= MAX_LATENCY_BUCKET_COUNT) return `invalid bucket. Expected a number between 0 and ${MAX_LATENCY_BUCKET_COUNT - 1}, got: ${b}`;
-
-  return [JSON.stringify({ s, n, i }), method, bucket];
-}

package/src/storages/inMemory/AttributesCacheInMemory.ts

@@ -7,10 +7,10 @@ export class AttributesCacheInMemory {
 
   /**
    * Create or update the value for the given attribute
-   * 
+   *
    * @param {string} attributeName attribute name
    * @param {Object} attributeValue attribute value
-   * @returns {boolean} the attribute was stored 
+   * @returns {boolean} the attribute was stored
    */
   setAttribute(attributeName: string, attributeValue: Object): boolean {
     this.attributesCache[attributeName] = attributeValue;
@@ -19,7 +19,7 @@ export class AttributesCacheInMemory {
 
   /**
    * Retrieves the value of a given attribute
-   * 
+   *
    * @param {string} attributeName attribute name
    * @returns {Object?} stored attribute value
    */
@@ -29,7 +29,7 @@ export class AttributesCacheInMemory {
 
   /**
    * Create or update all the given attributes
-   * 
+   *
    * @param {[string, Object]} attributes attributes to create or update
    * @returns {boolean} attributes were stored
    */
@@ -40,7 +40,7 @@ export class AttributesCacheInMemory {
 
   /**
    * Retrieve the full attributes map
-   * 
+   *
    * @returns {Map<string, Object>} stored attributes
    */
   getAll(): Record<string, Object> {
@@ -49,7 +49,7 @@ export class AttributesCacheInMemory {
 
   /**
    * Removes a given attribute from the map
-   * 
+   *
    * @param {string} attributeName attribute to remove
    * @returns {boolean} attribute removed
    */
@@ -63,7 +63,7 @@ export class AttributesCacheInMemory {
 
   /**
    * Clears all attributes stored in the SDK
-   * 
+   *
    */
   clear() {
     this.attributesCache = {};

package/src/storages/inRedis/ImpressionCountsCacheInRedis.ts

@@ -61,7 +61,7 @@ export class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory
 
         this.redis.del(this.key).catch(() => { /* no-op */ });
 
-        const impressionsCount: ImpressionCountsPayload = { pf: [] };
+        const pf: ImpressionCountsPayload['pf'] = [];
 
         forOwn(counts, (count, key) => {
           const nameAndTime = key.split('::');
@@ -82,14 +82,14 @@ export class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory
             return;
           }
 
-          impressionsCount.pf.push({
+          pf.push({
             f: nameAndTime[0],
             m: timeFrame,
             rc: rawCount,
           });
         });
 
-        return impressionsCount;
+        return { pf };
       });
   }
 }

package/src/storages/inRedis/ImpressionsCacheInRedis.ts

@@ -4,6 +4,7 @@ import { ImpressionDTO } from '../../types';
 import { Redis } from 'ioredis';
 import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
 import { ILogger } from '../../logger/types';
+import { impressionsToJSON } from '../utils';
 
 const IMPRESSIONS_TTL_REFRESH = 3600; // 1 hr
 
@@ -24,7 +25,7 @@ export class ImpressionsCacheInRedis implements IImpressionsCacheAsync {
   track(impressions: ImpressionDTO[]): Promise<void> { // @ts-ignore
     return this.redis.rpush(
       this.key,
-      this._toJSON(impressions)
+      impressionsToJSON(impressions, this.metadata),
     ).then(queuedCount => {
       // If this is the creation of the key on Redis, set the expiration for it in 1hr.
       if (queuedCount === impressions.length) {
@@ -33,27 +34,6 @@ export class ImpressionsCacheInRedis implements IImpressionsCacheAsync {
     });
   }
 
-  private _toJSON(impressions: ImpressionDTO[]): string[] {
-    return impressions.map(impression => {
-      const {
-        keyName, bucketingKey, feature, treatment, label, time, changeNumber
-      } = impression;
-
-      return JSON.stringify({
-        m: this.metadata,
-        i: {
-          k: keyName,
-          b: bucketingKey,
-          f: feature,
-          t: treatment,
-          r: label,
-          c: changeNumber,
-          m: time
-        }
-      });
-    });
-  }
-
   count(): Promise<number> {
     return this.redis.llen(this.key).catch(() => 0);
   }

package/src/storages/inRedis/TelemetryCacheInRedis.ts

@@ -1,6 +1,6 @@
 import { ILogger } from '../../logger/types';
 import { Method, MultiConfigs, MultiMethodExceptions, MultiMethodLatencies } from '../../sync/submitters/types';
-import { KeyBuilderSS, parseExceptionField, parseLatencyField, parseMetadata } from '../KeyBuilderSS';
+import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ITelemetryCacheAsync } from '../types';
 import { findLatencyIndex } from '../findLatencyIndex';
 import { Redis } from 'ioredis';
@@ -9,6 +9,7 @@ import { CONSUMER_MODE, STORAGE_REDIS } from '../../utils/constants';
 import { isNaNNumber, isString } from '../../utils/lang';
 import { _Map } from '../../utils/lang/maps';
 import { MAX_LATENCY_BUCKET_COUNT, newBuckets } from '../inMemory/TelemetryCacheInMemory';
+import { parseLatencyField, parseExceptionField, parseMetadata } from '../utils';
 
 export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
 

package/src/storages/inRedis/index.ts

@@ -10,7 +10,7 @@ import { DEBUG, NONE, STORAGE_REDIS } from '../../utils/constants';
 import { TelemetryCacheInRedis } from './TelemetryCacheInRedis';
 import { UniqueKeysCacheInRedis } from './UniqueKeysCacheInRedis';
 import { ImpressionCountsCacheInRedis } from './ImpressionCountsCacheInRedis';
-import { metadataBuilder } from '../metadataBuilder';
+import { metadataBuilder } from '../utils';
 
 export interface InRedisStorageOptions {
   prefix?: string

package/src/storages/pluggable/ImpressionCountsCachePluggable.ts

@@ -54,7 +54,7 @@ export class ImpressionCountsCachePluggable extends ImpressionCountsCacheInMemor
           .then(counts => {
             keys.forEach(key => this.wrapper.del(key).catch(() => { /* noop */ }));
 
-            const impressionsCount: ImpressionCountsPayload = { pf: [] };
+            const pf = [];
 
             for (let i = 0; i < keys.length; i++) {
               const key = keys[i];
@@ -78,14 +78,14 @@ export class ImpressionCountsCachePluggable extends ImpressionCountsCacheInMemor
                 continue;
               }
 
-              impressionsCount.pf.push({
+              pf.push({
                 f: keyFeatureNameAndTime[1],
                 m: timeFrame,
                 rc: rawCount,
               });
             }
 
-            return impressionsCount;
+            return { pf };
           }) : undefined;
       });
   }

package/src/storages/pluggable/ImpressionsCachePluggable.ts

@@ -1,8 +1,9 @@
 import { IPluggableStorageWrapper, IImpressionsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
 import { ImpressionDTO } from '../../types';
-import { ILogger } from '../../logger/types';
 import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
+import { ILogger } from '../../logger/types';
+import { impressionsToJSON } from '../utils';
 
 export class ImpressionsCachePluggable implements IImpressionsCacheAsync {
 
@@ -27,31 +28,10 @@ export class ImpressionsCachePluggable implements IImpressionsCacheAsync {
   track(impressions: ImpressionDTO[]): Promise<void> {
     return this.wrapper.pushItems(
       this.key,
-      this._toJSON(impressions)
+      impressionsToJSON(impressions, this.metadata)
     );
   }
 
-  private _toJSON(impressions: ImpressionDTO[]): string[] {
-    return impressions.map(impression => {
-      const {
-        keyName, bucketingKey, feature, treatment, label, time, changeNumber
-      } = impression;
-
-      return JSON.stringify({
-        m: this.metadata,
-        i: {
-          k: keyName,
-          b: bucketingKey,
-          f: feature,
-          t: treatment,
-          r: label,
-          c: changeNumber,
-          m: time
-        }
-      } as StoredImpressionWithMetadata);
-    });
-  }
-
   /**
    * Returns a promise that resolves with the count of stored impressions, or 0 if there was some error.
    * The promise will never be rejected.

package/src/storages/pluggable/TelemetryCachePluggable.ts

@@ -1,6 +1,6 @@
 import { ILogger } from '../../logger/types';
 import { Method, MultiConfigs, MultiMethodExceptions, MultiMethodLatencies } from '../../sync/submitters/types';
-import { KeyBuilderSS, parseExceptionField, parseLatencyField, parseMetadata } from '../KeyBuilderSS';
+import { KeyBuilderSS } from '../KeyBuilderSS';
 import { IPluggableStorageWrapper, ITelemetryCacheAsync } from '../types';
 import { findLatencyIndex } from '../findLatencyIndex';
 import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
@@ -8,6 +8,7 @@ import { CONSUMER_MODE, STORAGE_PLUGGABLE } from '../../utils/constants';
 import { isString, isNaNNumber } from '../../utils/lang';
 import { _Map } from '../../utils/lang/maps';
 import { MAX_LATENCY_BUCKET_COUNT, newBuckets } from '../inMemory/TelemetryCacheInMemory';
+import { parseLatencyField, parseExceptionField, parseMetadata } from '../utils';
 
 export class TelemetryCachePluggable implements ITelemetryCacheAsync {
 

package/src/storages/pluggable/inMemoryWrapper.ts

@@ -39,25 +39,25 @@ export function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWra
     getKeysByPrefix(prefix: string) {
       return Promise.resolve(Object.keys(_cache).filter(key => startsWith(key, prefix)));
     },
-    incr(key: string) {
+    incr(key: string, increment = 1) {
       if (key in _cache) {
-        const count = toNumber(_cache[key]) + 1;
+        const count = toNumber(_cache[key]) + increment;
         if (isNaN(count)) return Promise.reject('Given key is not a number');
         _cache[key] = count + '';
         return Promise.resolve(count);
       } else {
-        _cache[key] = '1';
+        _cache[key] = '' + increment;
         return Promise.resolve(1);
       }
     },
-    decr(key: string) {
+    decr(key: string, decrement = 1) {
       if (key in _cache) {
-        const count = toNumber(_cache[key]) - 1;
+        const count = toNumber(_cache[key]) - decrement;
         if (isNaN(count)) return Promise.reject('Given key is not a number');
         _cache[key] = count + '';
         return Promise.resolve(count);
       } else {
-        _cache[key] = '-1';
+        _cache[key] = '-' + decrement;
         return Promise.resolve(-1);
       }
     },

package/src/storages/pluggable/index.ts

@@ -18,7 +18,7 @@ import { ImpressionCountsCachePluggable } from './ImpressionCountsCachePluggable
 import { UniqueKeysCachePluggable } from './UniqueKeysCachePluggable';
 import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
-import { metadataBuilder } from '../metadataBuilder';
+import { metadataBuilder } from '../utils';
 
 const NO_VALID_WRAPPER = 'Expecting pluggable storage `wrapper` in options, but no valid wrapper instance was provided.';
 const NO_VALID_WRAPPER_INTERFACE = 'The provided wrapper instance doesn’t follow the expected interface. Check our docs.';

package/src/storages/types.ts

@@ -69,21 +69,21 @@ export interface IPluggableStorageWrapper {
   /** Integer operations */
 
   /**
-   * Increments the number stored at `key` by `increment` (or 1 if `increment` is not provided), or set it to `increment` (or 1) if the value doesn't exist.
+   * Increments the number stored at `key` by `increment`, or set it to `increment` if the value doesn't exist.
    *
    * @function incr
    * @param {string} key Key to increment
-   * @param {number} increment Value to increment by
+   * @param {number} increment Value to increment by. Defaults to 1.
    * @returns {Promise<number>} A promise that resolves with the value of key after the increment. The promise rejects if the operation fails,
    * for example, if there is a connection error or the key contains a string that can not be represented as integer.
    */
   incr: (key: string, increment?: number) => Promise<number>
   /**
-   * Decrements the number stored at `key` by `decrement` (or 1 if `decrement` is not provided), or set it to minus `decrement` (or minus 1) if the value doesn't exist.
+   * Decrements the number stored at `key` by `decrement`, or set it to minus `decrement` if the value doesn't exist.
    *
    * @function decr
    * @param {string} key Key to decrement
-   * @param {number} decrement Value to decrement by
+   * @param {number} decrement Value to decrement by. Defaults to 1.
    * @returns {Promise<number>} A promise that resolves with the value of key after the decrement. The promise rejects if the operation fails,
    * for example, if there is a connection error or the key contains a string that can not be represented as integer.
    */

package/src/storages/utils.ts

@@ -0,0 +1,78 @@
+// Shared utils for Redis and Pluggable storage
+
+import { IMetadata } from '../dtos/types';
+import { Method, StoredImpressionWithMetadata } from '../sync/submitters/types';
+import { ImpressionDTO, ISettings } from '../types';
+import { UNKNOWN } from '../utils/constants';
+import { MAX_LATENCY_BUCKET_COUNT } from './inMemory/TelemetryCacheInMemory';
+import { METHOD_NAMES } from './KeyBuilderSS';
+
+export function metadataBuilder(settings: Pick<ISettings, 'version' | 'runtime'>): IMetadata {
+  return {
+    s: settings.version,
+    i: settings.runtime.ip || UNKNOWN,
+    n: settings.runtime.hostname || UNKNOWN,
+  };
+}
+
+// Converts impressions to be stored in Redis or pluggable storage.
+export function impressionsToJSON(impressions: ImpressionDTO[], metadata: IMetadata): string[] {
+  return impressions.map(impression => {
+    const impressionWithMetadata: StoredImpressionWithMetadata = {
+      m: metadata,
+      i: {
+        k: impression.keyName,
+        b: impression.bucketingKey,
+        f: impression.feature,
+        t: impression.treatment,
+        r: impression.label,
+        c: impression.changeNumber,
+        m: impression.time,
+        pt: impression.pt,
+      }
+    };
+
+    return JSON.stringify(impressionWithMetadata);
+  });
+}
+
+// Utilities used by TelemetryCacheInRedis and TelemetryCachePluggable
+
+const REVERSE_METHOD_NAMES = Object.keys(METHOD_NAMES).reduce((acc, key) => {
+  acc[METHOD_NAMES[key as Method]] = key as Method;
+  return acc;
+}, {} as Record<string, Method>);
+
+
+export function parseMetadata(field: string): [metadata: string] | string {
+  const parts = field.split('/');
+  if (parts.length !== 3) return `invalid subsection count. Expected 3, got: ${parts.length}`;
+
+  const [s /* metadata.s */, n /* metadata.n */, i /* metadata.i */] = parts;
+  return [JSON.stringify({ s, n, i })];
+}
+
+export function parseExceptionField(field: string): [metadata: string, method: Method] | string {
+  const parts = field.split('/');
+  if (parts.length !== 4) return `invalid subsection count. Expected 4, got: ${parts.length}`;
+
+  const [s /* metadata.s */, n /* metadata.n */, i /* metadata.i */, m] = parts;
+  const method = REVERSE_METHOD_NAMES[m];
+  if (!method) return `unknown method '${m}'`;
+
+  return [JSON.stringify({ s, n, i }), method];
+}
+
+export function parseLatencyField(field: string): [metadata: string, method: Method, bucket: number] | string {
+  const parts = field.split('/');
+  if (parts.length !== 5) return `invalid subsection count. Expected 5, got: ${parts.length}`;
+
+  const [s /* metadata.s */, n /* metadata.n */, i /* metadata.i */, m, b] = parts;
+  const method = REVERSE_METHOD_NAMES[m];
+  if (!method) return `unknown method '${m}'`;
+
+  const bucket = parseInt(b);
+  if (isNaN(bucket) || bucket >= MAX_LATENCY_BUCKET_COUNT) return `invalid bucket. Expected a number between 0 and ${MAX_LATENCY_BUCKET_COUNT - 1}, got: ${b}`;
+
+  return [JSON.stringify({ s, n, i }), method, bucket];
+}

package/src/sync/submitters/types.ts

@@ -76,6 +76,8 @@ export type StoredImpressionWithMetadata = {
     c: number,
     /** time */
     m: number
+    /** previous time */
+    pt?: number
   }
 }
 

package/src/trackers/impressionsTracker.ts

@@ -31,9 +31,9 @@ export function impressionsTrackerFactory(
 
       const impressionsCount = impressions.length;
       const { impressionsToStore, impressionsToListener, deduped } = strategy.process(impressions);
-      
+
       const impressionsToListenerCount = impressionsToListener.length;
-      
+
       if ( impressionsToStore.length>0 ){
         const res = impressionsCache.track(impressionsToStore);
 

package/src/trackers/strategy/strategyDebug.ts

@@ -4,14 +4,14 @@ import { IStrategy } from '../types';
 
 /**
  * Debug strategy for impressions tracker. Wraps impressions to store and adds previousTime if it corresponds
- * 
+ *
  * @param impressionsObserver impression observer. Previous time (pt property) is included in impression instances
  * @returns IStrategyResult
  */
 export function strategyDebugFactory(
   impressionsObserver: IImpressionObserver
 ): IStrategy {
-  
+
   return {
     process(impressions: ImpressionDTO[]) {
       impressions.forEach((impression) => {
@@ -19,8 +19,8 @@ export function strategyDebugFactory(
         impression.pt = impressionsObserver.testAndSet(impression);
       });
       return {
-        impressionsToStore: impressions, 
-        impressionsToListener: impressions, 
+        impressionsToStore: impressions,
+        impressionsToListener: impressions,
         deduped: 0
       };
     }