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

package/src/storages/types.ts

@@ -1,7 +1,6 @@
-import { MaybeThenable, IMetadata, ISplitFiltersValidation, ISplit } from '../dtos/types';
-import { ILogger } from '../logger/types';
-import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs } from '../sync/submitters/types';
-import { SplitIO, ImpressionDTO, SDKMode } from '../types';
+import { MaybeThenable, ISplit } from '../dtos/types';
+import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload } from '../sync/submitters/types';
+import { SplitIO, ImpressionDTO, ISettings } from '../types';
 
 /**
  * Interface of a pluggable storage wrapper.
@@ -285,19 +284,29 @@ export interface ISegmentsCacheAsync extends ISegmentsCacheBase {
 /** Recorder storages (impressions, events and telemetry) */
 
 export interface IImpressionsCacheBase {
-  // Consumer API method, used by impressions tracker, in standalone and consumer modes, to push impressions into the storage.
+  // Used by impressions tracker, in DEBUG and OPTIMIZED impression modes, to push impressions into the storage.
   track(data: ImpressionDTO[]): MaybeThenable<void>
 }
 
 export interface IEventsCacheBase {
-  // Consumer API method, used by events tracker, in standalone and consumer modes, to push events into the storage.
+  // Used by events tracker to push events into the storage.
   track(data: SplitIO.EventData, size?: number): MaybeThenable<boolean>
 }
 
-/** Impressions and events cache for standalone mode (sync) */
+export interface IImpressionCountsCacheBase {
+  // Used by impressions tracker, in OPTIMIZED and NONE impression modes, to count impressions.
+  track(featureName: string, timeFrame: number, amount: number): void
+}
+
+export interface IUniqueKeysCacheBase {
+  // Used by impressions tracker, in NONE impression mode, to track unique keys.
+  track(key: string, value: string): void
+}
 
-// Producer API methods for sync recorder storages, used by submitters in standalone mode to pop data and post it to Split BE.
-export interface IRecorderCacheProducerSync<T> {
+/** Impressions and events cache for standalone and partial consumer modes (sync methods) */
+
+// API methods for sync recorder storages, used by submitters in standalone mode to pop data and post it to Split BE.
+export interface IRecorderCacheSync<T> {
   // @TODO names are inconsistent with spec
   /* Checks if cache is empty. Returns true if the cache was just created or cleared */
   isEmpty(): boolean
@@ -307,23 +316,29 @@ export interface IRecorderCacheProducerSync<T> {
   pop(toMerge?: T): T
 }
 
-
-export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderCacheProducerSync<ImpressionDTO[]> {
+export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderCacheSync<ImpressionDTO[]> {
   track(data: ImpressionDTO[]): void
   /* Registers callback for full queue */
   setOnFullQueueCb(cb: () => void): void
 }
 
-export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheProducerSync<SplitIO.EventData[]> {
+export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheSync<SplitIO.EventData[]> {
   track(data: SplitIO.EventData, size?: number): boolean
   /* Registers callback for full queue */
   setOnFullQueueCb(cb: () => void): void
 }
 
-/** Impressions and events cache for consumer and producer mode (async) */
+/* Named `ImpressionsCounter` in spec */
+export interface IImpressionCountsCacheSync extends IImpressionCountsCacheBase, IRecorderCacheSync<Record<string, number>> { }
 
-// Producer API methods for async recorder storages, used by submitters in producer mode to pop data and post it to Split BE.
-export interface IRecorderCacheProducerAsync<T> {
+export interface IUniqueKeysCacheSync  extends IUniqueKeysCacheBase, IRecorderCacheSync<UniqueKeysPayloadSs | UniqueKeysPayloadCs> {
+  setOnFullQueueCb(cb: () => void): void,
+}
+
+/** Impressions and events cache for consumer and producer modes (async methods) */
+
+// API methods for async recorder storages, used by submitters in producer mode (synchronizer) to pop data and post it to Split BE.
+export interface IRecorderCacheAsync<T> {
   /* returns the number of stored items */
   count(): Promise<number>
   /* removes the given number of items from the store. If not provided, it deletes all items */
@@ -332,43 +347,18 @@ export interface IRecorderCacheProducerAsync<T> {
   popNWithMetadata(count: number): Promise<T>
 }
 
-export interface IImpressionsCacheAsync extends IImpressionsCacheBase, IRecorderCacheProducerAsync<StoredImpressionWithMetadata[]> {
+export interface IImpressionsCacheAsync extends IImpressionsCacheBase, IRecorderCacheAsync<StoredImpressionWithMetadata[]> {
   // Consumer API method, used by impressions tracker (in standalone and consumer modes) to push data into.
   // The result promise can reject.
   track(data: ImpressionDTO[]): Promise<void>
 }
 
-export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheProducerAsync<StoredEventWithMetadata[]> {
+export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheAsync<StoredEventWithMetadata[]> {
   // Consumer API method, used by events tracker (in standalone and consumer modes) to push data into.
   // The result promise cannot reject.
   track(data: SplitIO.EventData, size?: number): Promise<boolean>
 }
 
-/**
- * Impression counts cache for impressions dedup in standalone and producer mode.
- * Only in memory. Named `ImpressionsCounter` in spec.
- */
-export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<Record<string, number>> {
-  // Used by impressions tracker
-  track(featureName: string, timeFrame: number, amount: number): void
-
-  // Used by impressions count submitter in standalone and producer mode
-  isEmpty(): boolean // check if cache is empty. Return true if the cache was just created or cleared.
-  pop(toMerge?: Record<string, number>): Record<string, number> // pop cache data
-}
-
-export interface IUniqueKeysCacheBase {
-  // Used by unique Keys tracker
-  track(key: string, value: string): void
-
-  // Used by unique keys submitter in standalone and producer mode
-  isEmpty(): boolean // check if cache is empty. Return true if the cache was just created or cleared.
-  pop(): UniqueKeysPayloadSs | UniqueKeysPayloadCs // pop cache data
-  /* Registers callback for full queue */
-  setOnFullQueueCb(cb: () => void): void,
-  clear(): void
-}
-
 /**
  * Telemetry storage interface for standalone and partial consumer modes.
  * Methods are sync because data is stored in memory.
@@ -428,7 +418,7 @@ export interface ITelemetryEvaluationProducerSync {
 
 export interface ITelemetryStorageProducerSync extends ITelemetryInitProducerSync, ITelemetryRuntimeProducerSync, ITelemetryEvaluationProducerSync { }
 
-export interface ITelemetryCacheSync extends ITelemetryStorageConsumerSync, ITelemetryStorageProducerSync { }
+export interface ITelemetryCacheSync extends ITelemetryStorageConsumerSync, ITelemetryStorageProducerSync, IRecorderCacheSync<TelemetryUsageStatsPayload> { }
 
 /**
  * Telemetry storage interface for consumer mode.
@@ -458,7 +448,7 @@ export interface IStorageBase<
   TSplitsCache extends ISplitsCacheBase,
   TSegmentsCache extends ISegmentsCacheBase,
   TImpressionsCache extends IImpressionsCacheBase,
-  TImpressionsCountCache extends IImpressionCountsCacheSync,
+  TImpressionsCountCache extends IImpressionCountsCacheBase,
   TEventsCache extends IEventsCacheBase,
   TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync,
   TUniqueKeysCache extends IUniqueKeysCacheBase
@@ -481,14 +471,14 @@ export interface IStorageSync extends IStorageBase<
   IImpressionCountsCacheSync,
   IEventsCacheSync,
   ITelemetryCacheSync,
-  IUniqueKeysCacheBase
+  IUniqueKeysCacheSync
   > { }
 
 export interface IStorageAsync extends IStorageBase<
   ISplitsCacheAsync,
   ISegmentsCacheAsync,
   IImpressionsCacheAsync | IImpressionsCacheSync,
-  IImpressionCountsCacheSync,
+  IImpressionCountsCacheBase,
   IEventsCacheAsync | IEventsCacheSync,
   ITelemetryCacheAsync | ITelemetryCacheSync,
   IUniqueKeysCacheBase
@@ -499,21 +489,12 @@ export interface IStorageAsync extends IStorageBase<
 export type DataLoader = (storage: IStorageSync, matchingKey: string) => void
 
 export interface IStorageFactoryParams {
-  log: ILogger,
-  impressionsQueueSize?: number,
-  eventsQueueSize?: number,
-  optimize?: boolean /* whether create the `impressionCounts` cache (OPTIMIZED impression mode) or not (DEBUG impression mode) */,
-  mode: SDKMode,
-  impressionsMode?: string,
-  // ATM, only used by InLocalStorage
-  matchingKey?: string, /* undefined on server-side SDKs */
-  splitFiltersValidation?: ISplitFiltersValidation,
-
-  // This callback is invoked when the storage is ready to be used. Error-first callback style: if an error is passed,
-  // it means that the storge fail to connect and shouldn't be used.
-  // It is meant for emitting SDK_READY event in consumer mode, and for synchronizer to wait before using the storage.
+  settings: ISettings,
+  /**
+   * Error-first callback invoked when the storage is ready to be used. An error means that the storage failed to connect and shouldn't be used.
+   * It is meant for emitting SDK_READY event in consumer mode, and waiting before using the storage in the synchronizer.
+   */
   onReadyCb: (error?: any) => void,
-  metadata: IMetadata,
 }
 
 export type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';

package/src/sync/submitters/submitter.ts

@@ -1,6 +1,6 @@
 import { syncTaskFactory } from '../syncTask';
 import { ISyncTask } from '../types';
-import { IRecorderCacheProducerSync } from '../../storages/types';
+import { IRecorderCacheSync } from '../../storages/types';
 import { ILogger } from '../../logger/types';
 import { SUBMITTERS_PUSH, SUBMITTERS_PUSH_FAILS, SUBMITTERS_PUSH_RETRY } from '../../logger/constants';
 import { IResponse } from '../../services/types';
@@ -11,7 +11,7 @@ import { IResponse } from '../../services/types';
 export function submitterFactory<T>(
   log: ILogger,
   postClient: (body: string) => Promise<IResponse>,
-  sourceCache: IRecorderCacheProducerSync<T>,
+  sourceCache: IRecorderCacheSync<T>,
   postRate: number,
   dataName: string,
   fromCacheToPayload?: (cacheData: T) => any,

package/src/sync/submitters/submitterManager.ts

@@ -16,7 +16,7 @@ export function submitterManagerFactory(params: ISdkFactoryContextSync): ISubmit
   const impressionCountsSubmitter = impressionCountsSubmitterFactory(params);
   if (impressionCountsSubmitter) submitters.push(impressionCountsSubmitter);
   const telemetrySubmitter = telemetrySubmitterFactory(params);
-  if (params.uniqueKeysTracker) submitters.push(uniqueKeysSubmitterFactory(params));
+  if (params.storage.uniqueKeys) submitters.push(uniqueKeysSubmitterFactory(params));
 
   return {
     // `onlyTelemetry` true if SDK is created with userConsent not GRANTED

package/src/sync/submitters/telemetrySubmitter.ts

@@ -1,7 +1,7 @@
-import { ISegmentsCacheSync, ISplitsCacheSync, ITelemetryCacheSync } from '../../storages/types';
+import { ITelemetryCacheSync } from '../../storages/types';
 import { submitterFactory, firstPushWindowDecorator } from './submitter';
-import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload, TelemetryConfigStats } from './types';
-import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, NONE, DEBUG_ENUM, OPTIMIZED_ENUM, NONE_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
+import { TelemetryConfigStatsPayload, TelemetryConfigStats } from './types';
+import { CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, NONE, DEBUG_ENUM, OPTIMIZED_ENUM, NONE_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
 import { SDK_READY, SDK_READY_FROM_CACHE } from '../../readiness/constants';
 import { ConsentStatus, ISettings, SDKMode } from '../../types';
 import { base } from '../../utils/settingsValidation';
@@ -9,41 +9,6 @@ import { usedKeysMap } from '../../utils/inputValidation/apiKey';
 import { timer } from '../../utils/timeTracker/timer';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 import { objectAssign } from '../../utils/lang/objectAssign';
-import { isStorageSync } from '../../trackers/impressionObserver/utils';
-
-/**
- * Converts data from telemetry cache into /metrics/usage request payload.
- */
-export function telemetryCacheStatsAdapter(telemetry: ITelemetryCacheSync, splits?: ISplitsCacheSync, segments?: ISegmentsCacheSync) {
-  return {
-    isEmpty() { return false; }, // There is always data in telemetry cache
-    clear() { }, //  No-op
-
-    // @TODO consider moving inside telemetry cache for code size reduction
-    pop(): TelemetryUsageStatsPayload {
-      return {
-        lS: telemetry.getLastSynchronization(),
-        mL: telemetry.popLatencies(),
-        mE: telemetry.popExceptions(),
-        hE: telemetry.popHttpErrors(),
-        hL: telemetry.popHttpLatencies(),
-        tR: telemetry.popTokenRefreshes(),
-        aR: telemetry.popAuthRejections(),
-        iQ: telemetry.getImpressionStats(QUEUED),
-        iDe: telemetry.getImpressionStats(DEDUPED),
-        iDr: telemetry.getImpressionStats(DROPPED),
-        spC: splits && splits.getSplitNames().length,
-        seC: segments && segments.getRegisteredSegments().length,
-        skC: segments && segments.getKeysCount(),
-        sL: telemetry.getSessionLength(),
-        eQ: telemetry.getEventStats(QUEUED),
-        eD: telemetry.getEventStats(DROPPED),
-        sE: telemetry.popStreamingEvents(),
-        t: telemetry.popTags(),
-      };
-    }
-  };
-}
 
 const OPERATION_MODE_MAP = {
   [STANDALONE_MODE]: STANDALONE_ENUM,
@@ -131,7 +96,7 @@ export function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, sett
  * Submitter that periodically posts telemetry data
  */
 export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
-  const { storage: { splits, segments, telemetry }, platform: { now } } = params;
+  const { storage: { telemetry }, platform: { now } } = params;
   if (!telemetry || !now) return; // No submitter created if telemetry cache is not defined
 
   const { settings, settings: { log, scheduler: { telemetryRefreshRate } }, splitApi, readiness, sdkReadinessManager } = params;
@@ -140,8 +105,7 @@ export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
   const submitter = firstPushWindowDecorator(
     submitterFactory(
       log, splitApi.postMetricsUsage,
-      // @TODO cannot provide splits and segments cache if they are async, because `submitterFactory` expects a sync storage source
-      isStorageSync(params.settings) ? telemetryCacheStatsAdapter(telemetry, splits, segments) : telemetryCacheStatsAdapter(telemetry),
+      telemetry,
       telemetryRefreshRate, 'telemetry stats', undefined, 0, true
     ),
     telemetryRefreshRate

package/src/sync/submitters/types.ts

@@ -112,9 +112,9 @@ export type SEGMENT = 'se';
 export type MY_SEGMENT = 'ms';
 export type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MY_SEGMENT;
 
-export type LastSync = Record<OperationType, number | undefined>
-export type HttpErrors = Record<OperationType, { [statusCode: string]: number }>
-export type HttpLatencies = Record<OperationType, Array<number>>
+export type LastSync = Partial<Record<OperationType, number | undefined>>
+export type HttpErrors = Partial<Record<OperationType, { [statusCode: string]: number }>>
+export type HttpLatencies = Partial<Record<OperationType, Array<number>>>
 
 export type TREATMENT = 't';
 export type TREATMENTS = 'ts';
@@ -123,9 +123,9 @@ export type TREATMENTS_WITH_CONFIG = 'tcs';
 export type TRACK = 'tr';
 export type Method = TREATMENT | TREATMENTS | TREATMENT_WITH_CONFIG | TREATMENTS_WITH_CONFIG | TRACK;
 
-export type MethodLatencies = Record<Method, Array<number>>;
+export type MethodLatencies = Partial<Record<Method, Array<number>>>;
 
-export type MethodExceptions = Record<Method, number>;
+export type MethodExceptions = Partial<Record<Method, number>>;
 
 export type CONNECTION_ESTABLISHED = 0;
 export type OCCUPANCY_PRI = 10;

package/src/trackers/impressionObserver/utils.ts

@@ -1,21 +1,6 @@
-import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE, OPTIMIZED, PRODUCER_MODE, STANDALONE_MODE } from '../../utils/constants';
+import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../../utils/constants';
 import { ISettings } from '../../types';
 
-/**
- * Checks if impressions previous time should be added or not.
- */
-export function shouldAddPt(settings: ISettings) {
-  return [PRODUCER_MODE, STANDALONE_MODE, CONSUMER_PARTIAL_MODE].indexOf(settings.mode) > -1 ? true : false;
-}
-
-/**
- * Checks if it should dedupe impressions or not.
- */
-export function shouldBeOptimized(settings: ISettings) {
-  if (!shouldAddPt(settings)) return false;
-  return settings.sync.impressionsMode === OPTIMIZED ? true : false;
-}
-
 /**
  * Storage is async if mode is consumer or partial consumer
  */

package/src/trackers/strategy/strategyNone.ts

@@ -1,32 +1,32 @@
-import { IImpressionCountsCacheSync } from '../../storages/types';
+import { IImpressionCountsCacheBase } from '../../storages/types';
 import { ImpressionDTO } from '../../types';
 import { IStrategy, IUniqueKeysTracker } from '../types';
 
 /**
  * None strategy for impressions tracker.
- * 
+ *
  * @param impressionsCounter cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
- * @param uniqueKeysTracker unique keys tracker in charge of tracking the unique keys per split. 
+ * @param uniqueKeysTracker unique keys tracker in charge of tracking the unique keys per split.
  * @returns IStrategyResult
  */
 export function strategyNoneFactory(
-  impressionsCounter: IImpressionCountsCacheSync,
+  impressionsCounter: IImpressionCountsCacheBase,
   uniqueKeysTracker: IUniqueKeysTracker
 ): IStrategy {
-  
+
   return {
     process(impressions: ImpressionDTO[]) {
-      impressions.forEach((impression) => {        
+      impressions.forEach((impression) => {
         const now = Date.now();
         // Increments impression counter per featureName
         impressionsCounter.track(impression.feature, now, 1);
         // Keep track by unique key
         uniqueKeysTracker.track(impression.keyName, impression.feature);
       });
-      
+
       return {
-        impressionsToStore: [], 
-        impressionsToListener: impressions, 
+        impressionsToStore: [],
+        impressionsToListener: impressions,
         deduped: 0
       };
     }

package/src/trackers/strategy/strategyOptimized.ts

@@ -1,4 +1,4 @@
-import { IImpressionCountsCacheSync } from '../../storages/types';
+import { IImpressionCountsCacheBase } from '../../storages/types';
 import { ImpressionDTO } from '../../types';
 import { truncateTimeFrame } from '../../utils/time';
 import { IImpressionObserver } from '../impressionObserver/types';
@@ -6,35 +6,35 @@ import { IStrategy } from '../types';
 
 /**
  * Optimized 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
  * @param impressionsCounter cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
  * @returns IStrategyResult
  */
 export function strategyOptimizedFactory(
   impressionsObserver: IImpressionObserver,
-  impressionsCounter: IImpressionCountsCacheSync,
+  impressionsCounter: IImpressionCountsCacheBase,
 ): IStrategy {
-  
+
   return {
     process(impressions: ImpressionDTO[]) {
       const impressionsToStore: ImpressionDTO[] = [];
       impressions.forEach((impression) => {
         impression.pt = impressionsObserver.testAndSet(impression);
-        
+
         const now = Date.now();
-        
+
         // Increments impression counter per featureName
         if (impression.pt) impressionsCounter.track(impression.feature, now, 1);
-  
+
         // Checks if the impression should be added in queue to be sent
         if (!impression.pt || impression.pt < truncateTimeFrame(now)) {
           impressionsToStore.push(impression);
         }
       });
       return {
-        impressionsToStore: impressionsToStore, 
-        impressionsToListener: impressions, 
+        impressionsToStore: impressionsToStore,
+        impressionsToListener: impressions,
         deduped: impressions.length - impressionsToStore.length
       };
     }

package/src/trackers/uniqueKeysTracker.ts

@@ -4,16 +4,16 @@ import { IUniqueKeysCacheBase } from '../storages/types';
 import { IFilterAdapter, IUniqueKeysTracker } from './types';
 
 const noopFilterAdapter = {
-  add() {return true;},
-  contains() {return true;},
-  clear() {}
+  add() { return true; },
+  contains() { return true; },
+  clear() { }
 };
 
 /**
  * Trackes uniques keys
  * Unique Keys Tracker will be in charge of checking if the MTK was already sent to the BE in the last period
- *  or schedule to be sent; if not it will be added in an internal cache and sent in the next post. 
- * 
+ * or schedule to be sent; if not it will be added in an internal cache and sent in the next post.
+ *
  * @param log Logger instance
  * @param uniqueKeysCache cache to save unique keys
  * @param filterAdapter filter adapter
@@ -42,7 +42,7 @@ export function uniqueKeysTrackerFactory(
     stop(): void {
       clearInterval(intervalId);
     }
-    
+
   };
 
 }

package/src/utils/settingsValidation/index.ts

@@ -154,8 +154,8 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   if (storage) withDefaults.storage = storage(withDefaults);
 
   // Validate key and TT (for client-side)
+  const maybeKey = withDefaults.core.key;
   if (validationParams.acceptKey) {
-    const maybeKey = withDefaults.core.key;
     // Although `key` is required in client-side, it can be omitted in LOCALHOST mode. In that case, the value `localhost_key` is used.
     if (withDefaults.mode === LOCALHOST_MODE && maybeKey === undefined) {
       withDefaults.core.key = 'localhost_key';
@@ -172,6 +172,10 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
         withDefaults.core.trafficType = validateTrafficType(log, maybeTT, 'Client instantiation');
       }
     }
+  } else {
+    // On server-side, key is undefined and used to distinguish from client-side
+    if (maybeKey !== undefined) log.warn('Provided `key` is ignored in server-side SDK.'); // @ts-ignore
+    withDefaults.core.key = undefined;
   }
 
   // Current ip/hostname information

package/types/storages/inMemory/TelemetryCacheInMemory.d.ts

@@ -1,13 +1,21 @@
-import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies } from '../../sync/submitters/types';
-import { IStorageFactoryParams, ITelemetryCacheSync } from '../types';
+import { ImpressionDataType, EventDataType, StreamingEvent, Method, OperationType, TelemetryUsageStatsPayload } from '../../sync/submitters/types';
+import { ISegmentsCacheSync, ISplitsCacheSync, IStorageFactoryParams, ITelemetryCacheSync } from '../types';
 export declare const MAX_LATENCY_BUCKET_COUNT = 23;
 export declare function newBuckets(): number[];
 /**
  * Record telemetry if mode is not localhost.
  * All factory instances track telemetry on server-side, and 0.1% on client-side.
  */
-export declare function shouldRecordTelemetry(params: IStorageFactoryParams): boolean;
+export declare function shouldRecordTelemetry({ settings }: IStorageFactoryParams): boolean;
 export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
+    private splits?;
+    private segments?;
+    constructor(splits?: ISplitsCacheSync | undefined, segments?: ISegmentsCacheSync | undefined);
+    private e;
+    isEmpty(): boolean;
+    clear(): void;
+    pop(): TelemetryUsageStatsPayload;
+    /** Config stats */
     private timeUntilReady?;
     getTimeUntilReady(): number | undefined;
     recordTimeUntilReady(ms: number): void;
@@ -17,6 +25,7 @@ export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
     private notReadyUsage;
     getNonReadyUsage(): number;
     recordNonReadyUsage(): void;
+    /** Usage stats */
     private impressionStats;
     getImpressionStats(type: ImpressionDataType): number;
     recordImpressionStats(type: ImpressionDataType, count: number): void;
@@ -24,13 +33,15 @@ export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
     getEventStats(type: EventDataType): number;
     recordEventStats(type: EventDataType, count: number): void;
     private lastSync;
-    getLastSynchronization(): LastSync;
+    getLastSynchronization(): Partial<Record<OperationType, number | undefined>>;
     recordSuccessfulSync(resource: OperationType, timeMs: number): void;
     private httpErrors;
-    popHttpErrors(): HttpErrors;
+    popHttpErrors(): Partial<Record<OperationType, {
+        [statusCode: string]: number;
+    }>>;
     recordHttpError(resource: OperationType, status: number): void;
     private httpLatencies;
-    popHttpLatencies(): HttpLatencies;
+    popHttpLatencies(): Partial<Record<OperationType, number[]>>;
     recordHttpLatency(resource: OperationType, latencyMs: number): void;
     private authRejections;
     popAuthRejections(): number;
@@ -48,9 +59,9 @@ export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
     getSessionLength(): number | undefined;
     recordSessionLength(ms: number): void;
     private exceptions;
-    popExceptions(): MethodExceptions;
+    popExceptions(): Partial<Record<Method, number>>;
     recordException(method: Method): void;
     private latencies;
-    popLatencies(): MethodLatencies;
+    popLatencies(): Partial<Record<Method, number[]>>;
     recordLatency(method: Method, latencyMs: number): void;
 }