@splitsoftware/splitio-commons 1.6.2-rc.3 → 1.6.2-rc.6

package/src/evaluator/index.ts

@@ -5,8 +5,8 @@ import { CONTROL } from '../utils/constants';
 import { ISplit, MaybeThenable } from '../dtos/types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
 import { IEvaluationResult } from './types';
-import { SplitKey, Attributes } from '../types';
-import { ILogger } from '../types';
+import { SplitIO } from '../types';
+import { ILogger } from '../logger/types';
 
 const treatmentException = {
   treatment: CONTROL,
@@ -24,9 +24,9 @@ function treatmentsException(splitNames: string[]) {
 
 export function evaluateFeature(
   log: ILogger,
-  key: SplitKey,
+  key: SplitIO.SplitKey,
   splitName: string,
-  attributes: Attributes | undefined,
+  attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
 ): MaybeThenable<IEvaluationResult> {
   let stringifiedSplit;
@@ -63,35 +63,35 @@ export function evaluateFeature(
 
 export function evaluateFeatures(
   log: ILogger,
-  key: SplitKey,
+  key: SplitIO.SplitKey,
   splitNames: string[],
-  attributes: Attributes | undefined,
+  attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
 ): MaybeThenable<Record<string, IEvaluationResult>> {
-  let stringifiedSplits;
+  let parsedSplits;
 
   try {
-    stringifiedSplits = storage.splits.getSplits(splitNames);
+    parsedSplits = storage.splits.getSplits(splitNames);
   } catch (e) {
     // Exception on sync `getSplits` storage. Not possible ATM with InMemory and InLocal storages.
     return treatmentsException(splitNames);
   }
 
-  return (thenable(stringifiedSplits)) ?
-    stringifiedSplits.then(splits => getEvaluations(log, splitNames, splits, key, attributes, storage))
+  return thenable(parsedSplits) ?
+    parsedSplits.then(splits => getEvaluations(log, splitNames, splits, key, attributes, storage))
       .catch(() => {
         // Exception on async `getSplits` storage. For example, when the storage is redis or
         // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
         return treatmentsException(splitNames);
       }) :
-    getEvaluations(log, splitNames, stringifiedSplits, key, attributes, storage);
+    getEvaluations(log, splitNames, parsedSplits, key, attributes, storage);
 }
 
 function getEvaluation(
   log: ILogger,
-  stringifiedSplit: string | null,
-  key: SplitKey,
-  attributes: Attributes | undefined,
+  splitJSON: ISplit | null,
+  key: SplitIO.SplitKey,
+  attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
 ): MaybeThenable<IEvaluationResult> {
   let evaluation: MaybeThenable<IEvaluationResult> = {
@@ -100,8 +100,7 @@ function getEvaluation(
     config: null
   };
 
-  if (stringifiedSplit) {
-    const splitJSON: ISplit = JSON.parse(stringifiedSplit);
+  if (splitJSON) {
     const split = Engine.parse(log, splitJSON, storage);
     evaluation = split.getTreatment(key, attributes, evaluateFeature);
 
@@ -125,9 +124,9 @@ function getEvaluation(
 function getEvaluations(
   log: ILogger,
   splitNames: string[],
-  splits: Record<string, string | null>,
-  key: SplitKey,
-  attributes: Attributes | undefined,
+  splits: Record<string, ISplit | null>,
+  key: SplitIO.SplitKey,
+  attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
 ): MaybeThenable<Record<string, IEvaluationResult>> {
   const result: Record<string, IEvaluationResult> = {};

package/src/evaluator/matchers/all.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_ALL } from '../../logger/constants';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 
 export function allMatcherContext(log: ILogger) {
   return function allMatcher(runtimeAttr: string): boolean {

package/src/evaluator/matchers/between.ts

@@ -1,6 +1,6 @@
 import { IBetweenMatcherData } from '../../dtos/types';
 import { ENGINE_MATCHER_BETWEEN } from '../../logger/constants';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 
 export function betweenMatcherContext(log: ILogger, ruleVO: IBetweenMatcherData) /*: Function */ {
   return function betweenMatcher(runtimeAttr: number): boolean {

package/src/evaluator/matchers/boolean.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_BOOLEAN } from '../../logger/constants';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 
 export function booleanMatcherContext(log: ILogger, ruleAttr: boolean) /*: Function */ {
   return function booleanMatcher(runtimeAttr: boolean): boolean {

package/src/evaluator/matchers/cont_all.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_CONTAINS_ALL } from '../../logger/constants';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { findIndex } from '../../utils/lang';
 
 export function containsAllSetMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {

package/src/evaluator/matchers/cont_any.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_CONTAINS_ANY } from '../../logger/constants';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { findIndex } from '../../utils/lang';
 
 export function containsAnySetMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {

package/src/evaluator/matchers/cont_str.ts

@@ -1,5 +1,5 @@
 import { isString } from '../../utils/lang';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { ENGINE_MATCHER_CONTAINS_STRING } from '../../logger/constants';
 
 export function containsStringMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {

package/src/evaluator/matchers/dependency.ts

@@ -1,6 +1,6 @@
 import { IDependencyMatcherData, MaybeThenable } from '../../dtos/types';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { thenable } from '../../utils/promise/thenable';
 import { IDependencyMatcherValue, IEvaluation, ISplitEvaluator } from '../types';
 import { ENGINE_MATCHER_DEPENDENCY, ENGINE_MATCHER_DEPENDENCY_PRE } from '../../logger/constants';

package/src/evaluator/matchers/eq.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_EQUAL } from '../../logger/constants';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 
 export function equalToMatcherContext(log: ILogger, ruleAttr: number) /*: Function */ {
   return function equalToMatcher(runtimeAttr: number): boolean {

package/src/evaluator/matchers/eq_set.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_EQUAL_TO_SET } from '../../logger/constants';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { findIndex } from '../../utils/lang';
 
 export function equalToSetMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {

package/src/evaluator/matchers/ew.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_ENDS_WITH } from '../../logger/constants';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { endsWith } from '../../utils/lang';
 
 export function endsWithMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {

package/src/evaluator/matchers/gte.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_GREATER } from '../../logger/constants';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 
 export function greaterThanEqualMatcherContext(log: ILogger, ruleAttr: number) /*: Function */ {
   return function greaterThanEqualMatcher(runtimeAttr: number): boolean {

package/src/evaluator/matchers/index.ts

@@ -17,7 +17,7 @@ import { booleanMatcherContext } from './boolean';
 import { stringMatcherContext } from './string';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import { IMatcher, IMatcherDto } from '../types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 
 const matchers = [
   undefined, // UNDEFINED: 0,

package/src/evaluator/matchers/lte.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_LESS } from '../../logger/constants';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 
 export function lessThanEqualMatcherContext(log: ILogger, ruleAttr: number) /*: function */ {
   return function lessThanEqualMatcher(runtimeAttr: number): boolean {

package/src/evaluator/matchers/part_of.ts

@@ -1,5 +1,5 @@
 import { findIndex } from '../../utils/lang';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { ENGINE_MATCHER_PART_OF } from '../../logger/constants';
 
 export function partOfSetMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {

package/src/evaluator/matchers/segment.ts

@@ -1,6 +1,6 @@
 import { MaybeThenable } from '../../dtos/types';
 import { ISegmentsCacheBase } from '../../storages/types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { thenable } from '../../utils/promise/thenable';
 import { ENGINE_MATCHER_SEGMENT } from '../../logger/constants';
 

package/src/evaluator/matchers/string.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_STRING_INVALID, ENGINE_MATCHER_STRING } from '../../logger/constants';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 
 export function stringMatcherContext(log: ILogger, ruleAttr: string) /*: Function */ {
   return function stringMatcher(runtimeAttr: string): boolean {

package/src/evaluator/matchers/sw.ts

@@ -1,5 +1,5 @@
 import { ENGINE_MATCHER_STARTS_WITH } from '../../logger/constants';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { startsWith } from '../../utils/lang';
 
 export function startsWithMatcherContext(log: ILogger, ruleAttr: string[]) /*: Function */ {

package/src/evaluator/matchers/whitelist.ts

@@ -1,5 +1,5 @@
 import { setToArray, ISet } from '../../utils/lang/sets';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { ENGINE_MATCHER_WHITELIST } from '../../logger/constants';
 
 export function whitelistMatcherContext(log: ILogger, ruleAttr: ISet<string>) /*: Function */ {

package/src/evaluator/parser/index.ts

@@ -9,8 +9,8 @@ import { thenable } from '../../utils/promise/thenable';
 import { IEvaluator, IMatcherDto, ISplitEvaluator } from '../types';
 import { ISplitCondition } from '../../dtos/types';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
-import { Attributes } from '../../types';
-import { ILogger } from '../../types';
+import { SplitIO } from '../../types';
+import { ILogger } from '../../logger/types';
 
 export function parser(log: ILogger, conditions: ISplitCondition[], storage: IStorageSync | IStorageAsync): IEvaluator {
   let predicates = [];
@@ -31,7 +31,7 @@ export function parser(log: ILogger, conditions: ISplitCondition[], storage: ISt
       const matcher = matcherFactory(log, matcherDto, storage);
 
       // Evaluator function.
-      return (key: string, attributes: Attributes | undefined, splitEvaluator: ISplitEvaluator) => {
+      return (key: string, attributes: SplitIO.Attributes | undefined, splitEvaluator: ISplitEvaluator) => {
         const value = sanitizeValue(log, key, matcherDto, attributes);
         const result = value !== undefined && matcher ? matcher(value, splitEvaluator) : false;
 

package/src/evaluator/types.ts

@@ -1,12 +1,12 @@
 import { IBetweenMatcherData, IDependencyMatcherData, MaybeThenable } from '../dtos/types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
 import { ISet } from '../utils/lang/sets';
-import { SplitKey, Attributes } from '../types';
-import { ILogger } from '../types';
+import { SplitIO } from '../types';
+import { ILogger } from '../logger/types';
 
 export interface IDependencyMatcherValue {
-  key: SplitKey,
-  attributes?: Attributes
+  key: SplitIO.SplitKey,
+  attributes?: SplitIO.Attributes
 }
 
 export interface IMatcherDto {
@@ -27,8 +27,8 @@ export interface IEvaluation {
 
 export type IEvaluationResult = IEvaluation & { treatment: string }
 
-export type ISplitEvaluator = (log: ILogger, key: SplitKey, splitName: string, attributes: Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
+export type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>
 
-export type IEvaluator = (key: SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | undefined>
+export type IEvaluator = (key: SplitIO.SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | undefined>
 
 export type IMatcher = (...args: any) => MaybeThenable<boolean>

package/src/evaluator/value/index.ts

@@ -1,10 +1,10 @@
-import { Attributes } from '../../types';
+import { SplitIO } from '../../types';
 import { IMatcherDto } from '../types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { sanitize } from './sanitize';
 import { ENGINE_VALUE, ENGINE_VALUE_NO_ATTRIBUTES, ENGINE_VALUE_INVALID } from '../../logger/constants';
 
-function parseValue(log: ILogger, key: string, attributeName: string | null, attributes?: Attributes) {
+function parseValue(log: ILogger, key: string, attributeName: string | null, attributes?: SplitIO.Attributes) {
   let value = undefined;
   if (attributeName) {
     if (attributes) {
@@ -23,7 +23,7 @@ function parseValue(log: ILogger, key: string, attributeName: string | null, att
 /**
  * Defines value to be matched (key / attribute).
  */
-export function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes?: Attributes) {
+export function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes?: SplitIO.Attributes) {
   const attributeName = matcherDto.attribute;
   const valueToMatch = parseValue(log, key, attributeName, attributes);
   const sanitizedValue = sanitize(log, matcherDto.type, valueToMatch, matcherDto.dataType, attributes);

package/src/evaluator/value/sanitize.ts

@@ -1,6 +1,6 @@
-import { Attributes } from '../../types';
+import { SplitIO } from '../../types';
 import { IDependencyMatcherValue } from '../types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { isObject, uniq, toString, toNumber } from '../../utils/lang';
 import { zeroSinceHH, zeroSinceSS } from '../convertions';
 import { matcherTypes, matcherDataTypes } from '../matchers/matcherTypes';
@@ -41,7 +41,7 @@ function sanitizeBoolean(val: any): boolean | undefined {
   return undefined;
 }
 
-function dependencyProcessor(sanitizedValue: string, attributes?: Attributes): IDependencyMatcherValue {
+function dependencyProcessor(sanitizedValue: string, attributes?: SplitIO.Attributes): IDependencyMatcherValue {
   return {
     key: sanitizedValue,
     attributes
@@ -69,7 +69,7 @@ function getProcessingFunction(matcherTypeID: number, dataType: string) {
 /**
  * Sanitize matcher value
  */
-export function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes?: Attributes) {
+export function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes?: SplitIO.Attributes) {
   const processor = getProcessingFunction(matcherTypeID, dataType);
   let sanitizedValue: string | number | boolean | Array<string | number> | IDependencyMatcherValue | undefined;
 

package/src/integrations/ga/GaToSplit.ts

@@ -8,10 +8,11 @@ import {
   validateKey,
   validateTrafficType,
 } from '../../utils/inputValidation';
-import { EventData } from '../../types';
+import { SplitIO } from '../../types';
 import { Identity, GoogleAnalyticsToSplitOptions } from './types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { IIntegrationFactoryParams } from '../types';
+import { ITelemetryTracker } from '../../trackers/types';
 
 const logPrefix = 'ga-to-split: ';
 const logNameMapper = 'ga-to-split:mapper';
@@ -25,7 +26,7 @@ const logNameMapper = 'ga-to-split:mapper';
  * @param log Logger instance.
  * @param autoRequire If true, log error when auto-require script is not detected
  */
-function providePlugin(window: any, pluginName: string, pluginConstructor: Function, log: ILogger, autoRequire?: boolean) {
+function providePlugin(window: any, pluginName: string, pluginConstructor: Function, log: ILogger, autoRequire: boolean, telemetryTracker?: ITelemetryTracker) {
   // get reference to global command queue. Init it if not defined yet.
   const gaAlias = window.GoogleAnalyticsObject || 'ga';
   window[gaAlias] = window[gaAlias] || function () {
@@ -35,10 +36,13 @@ function providePlugin(window: any, pluginName: string, pluginConstructor: Funct
   // provides the plugin for use with analytics.js.
   window[gaAlias]('provide', pluginName, pluginConstructor);
 
-  if (autoRequire && (!window[gaAlias].q || window[gaAlias].q.push === [].push)) {
-    // Expecting spy on ga.q push method but not found
+  const hasAutoRequire = window[gaAlias].q && window[gaAlias].q.push !== [].push;
+  if (autoRequire && !hasAutoRequire) { // Expecting spy on ga.q push method but not found
     log.error(logPrefix + 'integration is configured to autorequire the splitTracker plugin, but the necessary script does not seem to have run. Please check the docs.');
   }
+  if (telemetryTracker && hasAutoRequire) {
+    telemetryTracker.addTag('integration:ga-autorequire');
+  }
 }
 
 // Default mapping: object used for building the default mapper from hits to Split events
@@ -67,7 +71,7 @@ const defaultMapping = {
  * @param {object} mapping
  */
 function mapperBuilder(mapping: typeof defaultMapping) {
-  return function (model: UniversalAnalytics.Model): EventData {
+  return function (model: UniversalAnalytics.Model): SplitIO.EventData {
     const hitType: string = model.get('hitType');
     // @ts-expect-error
     const eventTypeId = model.get(mapping.eventTypeId[hitType] || 'hitType');
@@ -133,7 +137,7 @@ export function validateIdentities(identities?: Identity[]) {
  * @param {EventData} data event data instance to validate. Precondition: data != undefined
  * @returns {boolean} Whether the data instance is a valid EventData or not.
  */
-export function validateEventData(log: ILogger, eventData: any): eventData is EventData {
+export function validateEventData(log: ILogger, eventData: any): eventData is SplitIO.EventData {
   if (!validateEvent(log, eventData.eventTypeId, logNameMapper))
     return false;
 
@@ -191,7 +195,7 @@ export function fixEventTypeId(log: ILogger, eventTypeId: any) {
  */
 export function GaToSplit(sdkOptions: GoogleAnalyticsToSplitOptions, params: IIntegrationFactoryParams) {
 
-  const { storage, settings: { core: coreSettings, log } } = params;
+  const { storage, settings: { core: coreSettings, log }, telemetryTracker } = params;
 
   const defaultOptions = {
     prefix: defaultPrefix,
@@ -251,10 +255,10 @@ export function GaToSplit(sdkOptions: GoogleAnalyticsToSplitOptions, params: IIn
         }
 
         // map hit into an EventData instance
-        let eventData: EventData = defaultMapper(model);
+        let eventData: SplitIO.EventData = defaultMapper(model);
         if (opts.mapper) {
           try {
-            eventData = opts.mapper(model, eventData as EventData);
+            eventData = opts.mapper(model, eventData as SplitIO.EventData);
           } catch (err) {
             log.warn(logPrefix + `custom mapper threw: ${err}`);
             return;
@@ -291,5 +295,5 @@ export function GaToSplit(sdkOptions: GoogleAnalyticsToSplitOptions, params: IIn
   }
 
   // Register the plugin, even if config is invalid, since, if not provided, it will block `ga` command queue.
-  providePlugin(window, 'splitTracker', SplitTracker, log, sdkOptions.autoRequire === true);
+  providePlugin(window, 'splitTracker', SplitTracker, log, sdkOptions.autoRequire === true, telemetryTracker);
 }

package/src/integrations/ga/SplitToGa.ts

@@ -1,10 +1,10 @@
 /* eslint-disable no-undef */
 import { uniq } from '../../utils/lang';
 import { SPLIT_IMPRESSION, SPLIT_EVENT } from '../../utils/constants';
-import { IntegrationData, ImpressionData, EventData } from '../../types';
+import { SplitIO } from '../../types';
 import { IIntegration } from '../types';
 import { SplitToGoogleAnalyticsOptions } from './types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 
 const logPrefix = 'split-to-ga: ';
 const noGaWarning = '`ga` command queue not found.';
@@ -16,29 +16,29 @@ export class SplitToGa implements IIntegration {
   static defaultTrackerNames = [''];
 
   private trackerNames: string[];
-  private filter?: (data: IntegrationData) => boolean;
-  private mapper?: (data: IntegrationData, defaultMapping: UniversalAnalytics.FieldsObject) => UniversalAnalytics.FieldsObject;
+  private filter?: (data: SplitIO.IntegrationData) => boolean;
+  private mapper?: (data: SplitIO.IntegrationData, defaultMapping: UniversalAnalytics.FieldsObject) => UniversalAnalytics.FieldsObject;
   private impressions: boolean | undefined;
   private events: boolean | undefined;
   private log: ILogger;
 
   // Default mapper function.
-  static defaultMapper({ type, payload }: IntegrationData): UniversalAnalytics.FieldsObject {
+  static defaultMapper({ type, payload }: SplitIO.IntegrationData): UniversalAnalytics.FieldsObject {
     switch (type) {
       case SPLIT_IMPRESSION:
         return {
           hitType: 'event',
           eventCategory: 'split-impression',
-          eventAction: 'Evaluate ' + (payload as ImpressionData).impression.feature,
-          eventLabel: 'Treatment: ' + (payload as ImpressionData).impression.treatment + '. Targeting rule: ' + (payload as ImpressionData).impression.label + '.',
+          eventAction: 'Evaluate ' + (payload as SplitIO.ImpressionData).impression.feature,
+          eventLabel: 'Treatment: ' + (payload as SplitIO.ImpressionData).impression.treatment + '. Targeting rule: ' + (payload as SplitIO.ImpressionData).impression.label + '.',
           nonInteraction: true,
         };
       case SPLIT_EVENT:
         return {
           hitType: 'event',
           eventCategory: 'split-event',
-          eventAction: (payload as EventData).eventTypeId,
-          eventValue: (payload as EventData).value,
+          eventAction: (payload as SplitIO.EventData).eventTypeId,
+          eventValue: (payload as SplitIO.EventData).value,
           nonInteraction: true,
         };
     }
@@ -93,7 +93,7 @@ export class SplitToGa implements IIntegration {
     if (typeof SplitToGa.getGa() !== 'function') log.warn(logPrefix + `${noGaWarning} No hits will be sent until it is available.`);
   }
 
-  queue(data: IntegrationData) {
+  queue(data: SplitIO.IntegrationData) {
     // access ga command queue via `getGa` method, accounting for the possibility that
     // the global `ga` reference was not yet mutated by analytics.js.
     const ga = SplitToGa.getGa();

package/src/integrations/ga/types.ts

@@ -1,4 +1,4 @@
-import { IntegrationData, EventData } from '../../types';
+import { SplitIO } from '../../types';
 
 /**
  * A pair of user key and it's trafficType, required for tracking valid Split events.
@@ -41,7 +41,7 @@ export interface GoogleAnalyticsToSplitOptions {
    *      return defaultMapping;
    *  }`
    */
-  mapper?: (model: UniversalAnalytics.Model, defaultMapping: EventData) => EventData,
+  mapper?: (model: UniversalAnalytics.Model, defaultMapping: SplitIO.EventData) => SplitIO.EventData,
   /**
    * Optional prefix for EventTypeId, to prevent any kind of data collision between events.
    * @property {string} prefix
@@ -97,7 +97,7 @@ export interface SplitToGoogleAnalyticsOptions {
    * For example, the following filter allows to track only impressions, equivalent to setting events to false:
    *  `(data) => data.type === 'IMPRESSION'`
    */
-  filter?: (data: IntegrationData) => boolean,
+  filter?: (data: SplitIO.IntegrationData) => boolean,
   /**
    * Optional function useful when you need to modify the GA hit before sending it.
    * This function is invoked with two arguments:
@@ -128,7 +128,7 @@ export interface SplitToGoogleAnalyticsOptions {
    *    nonInteraction: true,
    *  }`
    */
-  mapper?: (data: IntegrationData, defaultMapping: UniversalAnalytics.FieldsObject) => UniversalAnalytics.FieldsObject,
+  mapper?: (data: SplitIO.IntegrationData, defaultMapping: UniversalAnalytics.FieldsObject) => UniversalAnalytics.FieldsObject,
   /**
    * List of tracker names to send the hit. An empty string represents the default tracker.
    * If not provided, hits are only sent to default tracker.

package/src/integrations/pluggable.ts

@@ -1,5 +1,5 @@
 import { SPLIT_IMPRESSION, SPLIT_EVENT } from '../utils/constants';
-import { ImpressionData, EventData } from '../types';
+import { SplitIO } from '../types';
 import { IIntegration, IIntegrationManager, IIntegrationFactoryParams } from './types';
 
 /**
@@ -29,10 +29,10 @@ export function pluggableIntegrationsManagerFactory(
 
   // Exception safe methods: each integration module is responsable for handling errors
   return {
-    handleImpression(impressionData: ImpressionData) {
+    handleImpression(impressionData: SplitIO.ImpressionData) {
       listeners.forEach(listener => listener.queue({ type: SPLIT_IMPRESSION, payload: impressionData }));
     },
-    handleEvent(eventData: EventData) {
+    handleEvent(eventData: SplitIO.EventData) {
       listeners.forEach(listener => listener.queue({ type: SPLIT_EVENT, payload: eventData }));
     }
   };

package/src/integrations/types.ts

@@ -1,9 +1,9 @@
 import { IEventsCacheBase } from '../storages/types';
-import { IEventsHandler, IImpressionsHandler } from '../trackers/types';
-import { ISettings, IntegrationData } from '../types';
+import { IEventsHandler, IImpressionsHandler, ITelemetryTracker } from '../trackers/types';
+import { ISettings, SplitIO } from '../types';
 
 export interface IIntegration {
-  queue(data: IntegrationData): void
+  queue(data: SplitIO.IntegrationData): void
 }
 
 export type IIntegrationManager = IEventsHandler & IImpressionsHandler;
@@ -11,6 +11,7 @@ export type IIntegrationManager = IEventsHandler & IImpressionsHandler;
 export interface IIntegrationFactoryParams {
   storage: { events: IEventsCacheBase }
   settings: ISettings
+  telemetryTracker: ITelemetryTracker
 }
 
 export type IntegrationFactory = {

package/src/logger/index.ts

@@ -1,10 +1,10 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { ILoggerOptions } from './types';
+import { ILoggerOptions, ILogger } from './types';
 import { find } from '../utils/lang';
-import { LogLevel, ILogger, ILoggerAPI } from '../types';
+import { LogLevel } from '../types';
 import { IMap, _Map } from '../utils/lang/maps';
 
-export const LogLevels: ILoggerAPI['LogLevel'] = {
+export const LogLevels: { [level: string]: LogLevel } = {
   DEBUG: 'DEBUG',
   INFO: 'INFO',
   WARN: 'WARN',

package/src/logger/sdkLogger.ts

@@ -1,5 +1,6 @@
 import { LogLevels, isLogLevelString } from './index';
-import { ILoggerAPI, ILogger } from '../types';
+import { ILoggerAPI } from '../types';
+import { ILogger } from './types';
 import { ERROR_LOGLEVEL_INVALID } from './constants';
 
 /**

package/src/logger/types.ts

@@ -5,3 +5,19 @@ export interface ILoggerOptions {
   logLevel?: LogLevel,
   showLevel?: boolean, // @TODO remove this param eventually since it is not being set `false` anymore
 }
+
+export interface ILogger {
+  setLogLevel(logLevel: LogLevel): void
+
+  debug(msg: any): void
+  debug(msg: string | number, args?: any[]): void
+
+  info(msg: any): void
+  info(msg: string | number, args?: any[]): void
+
+  warn(msg: any): void
+  warn(msg: string | number, args?: any[]): void
+
+  error(msg: any): void
+  error(msg: string | number, args?: any[]): void
+}

package/src/readiness/sdkReadinessManager.ts

@@ -4,7 +4,7 @@ import { readinessManagerFactory } from './readinessManager';
 import { ISdkReadinessManager } from './types';
 import { IEventEmitter } from '../types';
 import { SDK_READY, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE } from './constants';
-import { ILogger } from '../types';
+import { ILogger } from '../logger/types';
 import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY, CLIENT_NO_LISTENER } from '../logger/constants';
 
 const NEW_LISTENER_EVENT = 'newListener';