@ninetailed/experience.js 2.0.2 → 2.1.1-beta.0

package/index.esm.js

@@ -1,7 +1,7 @@
 import get$2 from 'lodash/get';
 import unionBy from 'lodash/unionBy';
 import { buildEmptyCache, buildTrackEvent, buildIdentifyEvent, buildPageEvent } from '@ninetailed/experience.js-shared';
-import * as loglevel from 'loglevel';
+import { diary, enable } from 'diary';
 import Analytics from 'analytics';
 import flatten from 'lodash/flatten';
 import find from 'lodash/find';
@@ -2236,15 +2236,6 @@ const buildClientNinetailedRequestContext = () => ({
   }
 });
 
-const enable = () => {
-  loglevel.enableAll();
-};
-const disable = () => {
-  loglevel.disableAll();
-};
-const Logger = loglevel.getLogger('ninetailed:experience.js');
-const log = Logger.log;
-
 const BASE_URL = 'https://api.ninetailed.co';
 
 const fetchWithTimeout = (input, init) => __awaiter(void 0, void 0, void 0, function* () {
@@ -2253,7 +2244,7 @@ const fetchWithTimeout = (input, init) => __awaiter(void 0, void 0, void 0, func
   } = init;
   const controller = new AbortController();
   const id = setTimeout(() => {
-    log(`Profile Request timed out.`);
+    logger.error(new Error('Ninetailed Request timed out.'));
     controller.abort();
   }, timeout);
   const response = yield fetch(input, Object.assign(Object.assign({}, init), {
@@ -2276,14 +2267,14 @@ class NinetailedApiClient {
 
   profile(options) {
     return __awaiter(this, void 0, void 0, function* () {
-      log('Sending Profile Request.');
+      logger.info('Sending Profile Request.');
       const {
         events
       } = options; // TODO throw error if not all events have same anon id.
 
       const anonymousId = events[0].anonymousId;
       const body = options;
-      log('Profile Request Body: ', body);
+      logger.debug('Profile Request Body: ', body);
 
       try {
         const request = yield fetchWithTimeout(`${this.url}/v1/organizations/${this.clientId}/environments/${this.environment}/profiles/${anonymousId}/events`, {
@@ -2294,15 +2285,15 @@ class NinetailedApiClient {
           body: JSON.stringify(body),
           timeout: options.timeout || 3000
         });
-        log('Profile Request: ', request);
+        logger.debug('Profile Request: ', request);
         const {
           data
         } = yield request.json();
-        log('Profile Request completed.');
+        logger.debug('Profile Request completed.');
         return data;
       } catch (error) {
         // TODO only during debug.
-        log(error);
+        logger.error(error);
         throw error;
       }
     });
@@ -2310,259 +2301,6 @@ class NinetailedApiClient {
 
 }
 
-const NINETAILED_TRACKER_EVENTS = {
-  /**
-   * `profile` - Fires when the profile is returned by the cdp API.
-   */
-  profile: 'profile'
-};
-const PLUGIN_NAME = 'ninetailed';
-
-const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
-/**
- * Similar to _.throttle but waits for the promise to resolve. There is no
- * wait time because you can simply await `Promise.timeout` inside `fn`
- * to wait some time before the next call.
- */
-
-
-function asyncThrottle(fn) {
-  let runningPromise;
-  let queuedPromise;
-  let nextArgs;
-  return args => __awaiter(this, void 0, void 0, function* () {
-    if (runningPromise) {
-      nextArgs = args;
-
-      if (queuedPromise) {
-        return queuedPromise;
-      } else {
-        queuedPromise = runningPromise.then(() => {
-          queuedPromise = undefined;
-          runningPromise = fn(nextArgs);
-          return runningPromise;
-        });
-        return queuedPromise;
-      }
-    } else {
-      runningPromise = fn(args);
-      return runningPromise;
-    }
-  });
-}
-const ninetailedPlugin = ({
-  clientId,
-  environment,
-  preview: _preview = false,
-  url,
-  profile,
-  locale
-}) => {
-  let isInitialized = false;
-  const apiClient = new NinetailedApiClient({
-    clientId,
-    environment,
-    url
-  });
-  let queue = [];
-  let localOnly = false;
-
-  const flush = instance => __awaiter(void 0, void 0, void 0, function* () {
-    const events = Object.assign([], queue);
-    log('Start flushing events.');
-    queue = [];
-
-    if (!events.length) {
-      return;
-    }
-
-    const cache = get({
-      instance
-    });
-
-    try {
-      log('Cache: ', cache);
-      const {
-        profile,
-        signals,
-        traitsUpdatedAt,
-        sessions
-      } = yield apiClient.profile({
-        events,
-        signals: get$2(cache, 'signals', {}),
-        traits: get$2(cache, 'traits', {}),
-        traitsUpdatedAt: get$2(cache, 'traitsUpdatedAt', new Date().toISOString()),
-        localOnly,
-        preview: _preview,
-        options: {
-          locale: locale || 'en'
-        },
-        sessions: get$2(cache, 'sessions', [])
-      });
-      log('Profile from api: ', profile);
-      const updatedCache = set({
-        id: profile.id,
-        random: profile.random,
-        audiences: profile.audiences,
-        traits: profile.traits,
-        location: profile.location,
-        signals,
-        traitsUpdatedAt,
-        sessions,
-        session: profile.session
-      }, {
-        instance
-      });
-      instance.dispatch({
-        type: NINETAILED_TRACKER_EVENTS.profile,
-        profile,
-        cache: updatedCache
-      });
-    } catch (error) {
-      log('An error occurred during flushing the events: ', error);
-      instance.dispatch({
-        type: NINETAILED_TRACKER_EVENTS.profile,
-        profile: {
-          id: cache.id,
-          random: cache.random,
-          audiences: cache.audiences,
-          traits: cache.traits,
-          location: cache.location,
-          session: cache.session
-        },
-        cache
-      });
-    } // This is necessary to make sure that the cache is updated before the next flush is performed
-
-
-    yield delay(20);
-  }); // const throttledFlush = throttle(flush, 200, {
-  //   leading: false,
-  //   trailing: true,
-  // });
-
-
-  const throttledFlush = asyncThrottle(flush);
-
-  const createEvent = (event, instance) => __awaiter(void 0, void 0, void 0, function* () {
-    queue = unionBy([event], queue, 'messageId');
-    throttledFlush(instance);
-  });
-
-  return {
-    name: 'ninetailed',
-    config: {},
-    initialize: ({
-      instance
-    }) => {
-      const cache = get({
-        instance
-      });
-
-      if (profile) {
-        instance.storage.setItem('__anon_id', profile.id);
-        initialize({
-          instance
-        }, Object.assign(Object.assign({}, cache), {
-          id: profile.id
-        }));
-      } else {
-        const anonymousId = instance.storage.getItem('__anon_id');
-        initialize({
-          instance
-        }, Object.assign(Object.assign({}, cache), {
-          id: anonymousId
-        }));
-      }
-
-      isInitialized = true;
-    },
-    page: ({
-      payload,
-      instance
-    }) => __awaiter(void 0, void 0, void 0, function* () {
-      log('Sending Page event.');
-      const ctx = buildClientNinetailedRequestContext();
-      localOnly = payload.localOnly;
-      yield createEvent(buildPageEvent({
-        // doing this here as the anonymous id is set to late from init
-        anonymousId: (profile === null || profile === void 0 ? void 0 : profile.id) || payload.anonymousId,
-        messageId: payload.meta.rid,
-        timestamp: payload.meta.ts,
-        properties: payload.properties,
-        ctx
-      }), instance);
-    }),
-    track: ({
-      payload,
-      instance
-    }) => __awaiter(void 0, void 0, void 0, function* () {
-      log('Sending Track event.');
-      const ctx = buildClientNinetailedRequestContext();
-      localOnly = payload.localOnly;
-      yield createEvent(buildTrackEvent({
-        // doing this here as the anonymous id is set to late from init
-        anonymousId: (profile === null || profile === void 0 ? void 0 : profile.id) || payload.anonymousId,
-        messageId: payload.meta.rid,
-        timestamp: payload.meta.ts,
-        event: payload.event,
-        properties: payload.properties,
-        ctx
-      }), instance);
-    }),
-    identify: ({
-      payload,
-      instance
-    }) => __awaiter(void 0, void 0, void 0, function* () {
-      log('Sending Identify event.');
-      localOnly = payload.localOnly;
-      const ctx = buildClientNinetailedRequestContext();
-      yield createEvent(buildIdentifyEvent({
-        // doing this here as the anonymous id is set to late from init
-        anonymousId: (profile === null || profile === void 0 ? void 0 : profile.id) || payload.anonymousId,
-        messageId: payload.meta.rid,
-        timestamp: payload.meta.ts,
-        traits: payload.traits,
-        userId: payload.userId,
-        ctx
-      }), instance);
-    }),
-    loaded: () => {
-      return isInitialized;
-    },
-    methods: {
-      reset: (...args) => __awaiter(void 0, void 0, void 0, function* () {
-        const instance = args[args.length - 1];
-        const cache = reset({
-          instance
-        });
-        yield instance.storage.setItem('__anon_id', cache.id);
-        instance.dispatch({
-          type: NINETAILED_TRACKER_EVENTS.profile,
-          profile: {
-            id: cache.id,
-            random: 0,
-            audiences: [],
-            traits: {},
-            location: {}
-          },
-          cache: cache
-        });
-        yield delay(10);
-      }),
-      debug: enabled => {
-        if (enabled) {
-          enable();
-          log('Debug mode is now enabled.');
-        } else {
-          disable();
-          log('Debug mode is now disabled.');
-        }
-      }
-    }
-  };
-};
-
 var objectDefineProperties = {};
 
 var DESCRIPTORS$1 = descriptors;
@@ -3023,34 +2761,429 @@ for (var COLLECTION_NAME in DOMIterables) {
 
 handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
 
-class Ninetailed {
-  constructor({
-    clientId,
-    environment,
-    preview
-  }, {
-    plugins,
-    url,
-    profile,
-    locale,
-    requestTimeout
-  } = {}) {
-    this.page = (data, options) => {
-      return this.instance.page(data, this.buildOptions(options));
-    };
+class Logger {
+  constructor() {
+    this.name = '@ninetailed/experience.js';
+    this.sinks = [];
+    this.diary = diary(this.name, this.onLogEvent.bind(this));
+    enable(this.name);
+  }
+
+  addSink(sink) {
+    this.sinks = [...this.sinks, sink];
+  }
+
+  removeSink(name) {
+    this.sinks = this.sinks.filter(sink => sink.name !== name);
+  }
+
+  debug(message, ...args) {
+    this.diary.debug(message, ...args);
+  }
+
+  info(message, ...args) {
+    this.diary.info(message, ...args);
+  }
+
+  log(message, ...args) {
+    this.diary.log(message, ...args);
+  }
+
+  warn(message, ...args) {
+    this.diary.warn(message, ...args);
+  }
+
+  error(message, ...args) {
+    this.diary.error(message, ...args);
+  }
+
+  fatal(message, ...args) {
+    this.diary.fatal(message, ...args);
+  }
+
+  onLogEvent(event) {
+    this.sinks.forEach(sink => {
+      if (sink[event.level]) {
+        sink[event.level](event.message, ...event.extra);
+      }
+    });
+  }
+
+}
+const logger = new Logger();
+
+class ConsoleLogSink {
+  constructor() {
+    this.name = "ConsoleLogSink";
+  }
+
+  debug(message, ...args) {
+    console.debug(message, ...args);
+  }
+
+  info(message, ...args) {
+    console.info(message, ...args);
+  }
+
+  log(message, ...args) {
+    console.log(message, ...args);
+  }
+
+  warn(message, ...args) {
+    console.warn(message, ...args);
+  }
+
+  error(message, ...args) {
+    console.error(message, ...args);
+  }
+
+  fatal(message, ...args) {
+    console.error(message, ...args);
+  }
+
+}
+
+class OnLogLogSink {
+  constructor(onLog) {
+    this.onLog = onLog;
+    this.name = 'OnLogLogSink';
+  }
+
+  debug(message, ...args) {
+    this.onLog(message, ...args);
+  }
+
+  info(message, ...args) {
+    this.onLog(message, ...args);
+  }
+
+  log(message, ...args) {
+    this.onLog(message, ...args);
+  }
+
+  warn(message, ...args) {
+    this.onLog(message, ...args);
+  }
+
+}
+
+class OnErrorLogSink {
+  constructor(onError) {
+    this.onError = onError;
+    this.name = 'OnErrorLogSink';
+  }
 
-    this.track = (event, payload, options) => {
+  error(message, ...args) {
+    this.onError(message, ...args);
+  }
+
+  fatal(message, ...args) {
+    this.onError(message, ...args);
+  }
+
+}
+
+const NINETAILED_TRACKER_EVENTS = {
+  /**
+   * `profile` - Fires when the profile is returned by the cdp API.
+   */
+  profile: 'profile'
+};
+const PLUGIN_NAME = 'ninetailed';
+const DEBUG_FLAG_KEY = 'nt-debug';
+
+const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+/**
+ * Similar to _.throttle but waits for the promise to resolve. There is no
+ * wait time because you can simply await `Promise.timeout` inside `fn`
+ * to wait some time before the next call.
+ */
+
+
+function asyncThrottle(fn) {
+  let runningPromise;
+  let queuedPromise;
+  let nextArgs;
+  return args => __awaiter(this, void 0, void 0, function* () {
+    if (runningPromise) {
+      nextArgs = args;
+
+      if (queuedPromise) {
+        return queuedPromise;
+      } else {
+        queuedPromise = runningPromise.then(() => {
+          queuedPromise = undefined;
+          runningPromise = fn(nextArgs);
+          return runningPromise;
+        });
+        return queuedPromise;
+      }
+    } else {
+      runningPromise = fn(args);
+      return runningPromise;
+    }
+  });
+}
+const ninetailedPlugin = ({
+  clientId,
+  environment,
+  preview: _preview = false,
+  url,
+  profile,
+  locale
+}) => {
+  let isInitialized = false;
+  const apiClient = new NinetailedApiClient({
+    clientId,
+    environment,
+    url
+  });
+  let queue = [];
+  let localOnly = false;
+
+  const flush = instance => __awaiter(void 0, void 0, void 0, function* () {
+    const events = Object.assign([], queue);
+    logger.info('Start flushing events.');
+    queue = [];
+
+    if (!events.length) {
+      return;
+    }
+
+    const cache = get({
+      instance
+    });
+
+    try {
+      logger.debug('Cache: ', cache);
+      const {
+        profile,
+        signals,
+        traitsUpdatedAt,
+        sessions
+      } = yield apiClient.profile({
+        events,
+        signals: get$2(cache, 'signals', {}),
+        traits: get$2(cache, 'traits', {}),
+        traitsUpdatedAt: get$2(cache, 'traitsUpdatedAt', new Date().toISOString()),
+        localOnly,
+        preview: _preview,
+        options: {
+          locale: locale || 'en'
+        },
+        sessions: get$2(cache, 'sessions', [])
+      });
+      logger.debug('Profile from api: ', profile);
+      const updatedCache = set({
+        id: profile.id,
+        random: profile.random,
+        audiences: profile.audiences,
+        traits: profile.traits,
+        location: profile.location,
+        signals,
+        traitsUpdatedAt,
+        sessions,
+        session: profile.session
+      }, {
+        instance
+      });
+      instance.dispatch({
+        type: NINETAILED_TRACKER_EVENTS.profile,
+        profile,
+        cache: updatedCache
+      });
+    } catch (error) {
+      logger.debug('An error occurred during flushing the events: ', error);
+      instance.dispatch({
+        type: NINETAILED_TRACKER_EVENTS.profile,
+        profile: {
+          id: cache.id,
+          random: cache.random,
+          audiences: cache.audiences,
+          traits: cache.traits,
+          location: cache.location,
+          session: cache.session
+        },
+        cache
+      });
+    } // This is necessary to make sure that the cache is updated before the next flush is performed
+
+
+    yield delay(20);
+  }); // const throttledFlush = throttle(flush, 200, {
+  //   leading: false,
+  //   trailing: true,
+  // });
+
+
+  const throttledFlush = asyncThrottle(flush);
+
+  const createEvent = (event, instance) => __awaiter(void 0, void 0, void 0, function* () {
+    queue = unionBy([event], queue, 'messageId');
+    throttledFlush(instance);
+  });
+
+  return {
+    name: 'ninetailed',
+    config: {},
+    initialize: ({
+      instance
+    }) => {
+      if (instance.storage.getItem(DEBUG_FLAG_KEY)) {
+        logger.addSink(new ConsoleLogSink());
+      }
+
+      const cache = get({
+        instance
+      });
+
+      if (profile) {
+        instance.storage.setItem('__anon_id', profile.id);
+        initialize({
+          instance
+        }, Object.assign(Object.assign({}, cache), {
+          id: profile.id
+        }));
+      } else {
+        const anonymousId = instance.storage.getItem('__anon_id');
+        initialize({
+          instance
+        }, Object.assign(Object.assign({}, cache), {
+          id: anonymousId
+        }));
+      }
+
+      isInitialized = true;
+      logger.debug('Ninetailed Core plugin initialized.');
+    },
+    page: ({
+      payload,
+      instance
+    }) => __awaiter(void 0, void 0, void 0, function* () {
+      logger.info('Sending Page event.');
+      const ctx = buildClientNinetailedRequestContext();
+      localOnly = payload.localOnly;
+      yield createEvent(buildPageEvent({
+        // doing this here as the anonymous id is set to late from init
+        anonymousId: (profile === null || profile === void 0 ? void 0 : profile.id) || payload.anonymousId,
+        messageId: payload.meta.rid,
+        timestamp: payload.meta.ts,
+        properties: payload.properties,
+        ctx
+      }), instance);
+    }),
+    track: ({
+      payload,
+      instance
+    }) => __awaiter(void 0, void 0, void 0, function* () {
+      logger.info('Sending Track event.');
+      const ctx = buildClientNinetailedRequestContext();
+      localOnly = payload.localOnly;
+      yield createEvent(buildTrackEvent({
+        // doing this here as the anonymous id is set to late from init
+        anonymousId: (profile === null || profile === void 0 ? void 0 : profile.id) || payload.anonymousId,
+        messageId: payload.meta.rid,
+        timestamp: payload.meta.ts,
+        event: payload.event,
+        properties: payload.properties,
+        ctx
+      }), instance);
+    }),
+    identify: ({
+      payload,
+      instance
+    }) => __awaiter(void 0, void 0, void 0, function* () {
+      logger.info('Sending Identify event.');
+      localOnly = payload.localOnly;
+      const ctx = buildClientNinetailedRequestContext();
+      yield createEvent(buildIdentifyEvent({
+        // doing this here as the anonymous id is set to late from init
+        anonymousId: (profile === null || profile === void 0 ? void 0 : profile.id) || payload.anonymousId,
+        messageId: payload.meta.rid,
+        timestamp: payload.meta.ts,
+        traits: payload.traits,
+        userId: payload.userId,
+        ctx
+      }), instance);
+    }),
+    loaded: () => {
+      return isInitialized;
+    },
+    methods: {
+      reset: (...args) => __awaiter(void 0, void 0, void 0, function* () {
+        const instance = args[args.length - 1];
+        const cache = reset({
+          instance
+        });
+        yield instance.storage.setItem('__anon_id', cache.id);
+        instance.dispatch({
+          type: NINETAILED_TRACKER_EVENTS.profile,
+          profile: {
+            id: cache.id,
+            random: 0,
+            audiences: [],
+            traits: {},
+            location: {}
+          },
+          cache: cache
+        });
+        yield delay(10);
+      }),
+      debug: (...args) => __awaiter(void 0, void 0, void 0, function* () {
+        const enabled = args[0];
+        const instance = args[args.length - 1];
+        const consoleLogSink = new ConsoleLogSink();
+
+        if (enabled) {
+          yield instance.storage.setItem(DEBUG_FLAG_KEY, true); // cleanup other console log sinks if there are already some.
+
+          logger.removeSink(consoleLogSink.name);
+          logger.addSink(consoleLogSink);
+          logger.info('Debug mode enabled.');
+        } else {
+          yield instance.storage.removeItem(DEBUG_FLAG_KEY);
+          logger.info('Debug mode disabled.');
+          logger.removeSink(consoleLogSink.name);
+        }
+      })
+    }
+  };
+};
+
+class Ninetailed {
+  constructor({
+    clientId,
+    environment,
+    preview
+  }, {
+    plugins,
+    url,
+    profile,
+    locale,
+    requestTimeout,
+    onLog,
+    onError
+  } = {}) {
+    this.isInitialized = false;
+
+    this.page = (data, options) => __awaiter(this, void 0, void 0, function* () {
+      yield this.waitUntilInitialized();
+      return this.instance.page(data, this.buildOptions(options));
+    });
+
+    this.track = (event, payload, options) => __awaiter(this, void 0, void 0, function* () {
+      yield this.waitUntilInitialized();
       return this.instance.track(event, payload, this.buildOptions(options));
-    };
+    });
 
-    this.trackHasSeenComponent = payload => {
+    this.trackHasSeenComponent = payload => __awaiter(this, void 0, void 0, function* () {
       return this.track('hasSeenComponent', payload, {
         plugins: {
           all: true,
           ninetailed: false
         }
       });
-    };
+    });
 
     this.trackExperience = payload => {
       return this.track('nt_experience', payload, {
@@ -3061,16 +3194,21 @@ class Ninetailed {
       });
     };
 
-    this.identify = (uid, traits, options) => {
+    this.identify = (uid, traits, options) => __awaiter(this, void 0, void 0, function* () {
+      yield this.waitUntilInitialized();
       return this.instance.identify(uid, traits, this.buildOptions(options));
-    };
+    });
 
     this.reset = () => {
-      return this.instance.plugins[PLUGIN_NAME].reset();
+      this.onIsInitialized(() => {
+        this.instance.plugins[PLUGIN_NAME].reset();
+      });
     };
 
     this.debug = enabled => {
-      return this.instance.plugins[PLUGIN_NAME].debug(enabled);
+      this.onIsInitialized(() => {
+        this.instance.plugins[PLUGIN_NAME].debug(enabled);
+      });
     };
 
     this.onProfileChange = cb => {
@@ -3086,6 +3224,25 @@ class Ninetailed {
       });
     };
 
+    this.onIsInitialized = onIsInitialized => {
+      if (typeof onIsInitialized === 'function') {
+        if (this.isInitialized) {
+          onIsInitialized();
+        } else {
+          const detachOnReadyListener = this.instance.on('ready', () => {
+            onIsInitialized();
+            detachOnReadyListener();
+          });
+        }
+      }
+    };
+
+    this.waitUntilInitialized = () => {
+      return new Promise(resolve => {
+        this.onIsInitialized(resolve);
+      });
+    };
+
     this.plugins = flatten(plugins || []);
 
     if (profile) {
@@ -3104,6 +3261,15 @@ class Ninetailed {
       };
     }
 
+    if (typeof onLog === 'function') {
+      logger.addSink(new OnLogLogSink(onLog));
+    }
+
+    if (typeof onError === 'function') {
+      logger.addSink(new OnErrorLogSink(onError));
+    }
+
+    this.logger = logger;
     this.instance = Analytics({
       app: 'ninetailed',
       plugins: [...this.plugins, ninetailedPlugin({
@@ -3115,6 +3281,11 @@ class Ninetailed {
         requestTimeout,
         preview
       })]
+    });
+    const detachOnReadyListener = this.instance.on('ready', () => {
+      this.isInitialized = true;
+      logger.info('Ninetailed Experience.js SDK is completely initialized.');
+      detachOnReadyListener();
     }); // put in private method
 
     this.onProfileChange(profileState => {
@@ -3909,13 +4080,13 @@ const isExperienceMatch = ({
   profile
 }) => {
   const trafficRandom = getTrafficRandom(profile, experience);
-  log(`The traffic random factor for experience ${experience.id} is ${trafficRandom}. It's traffic allocation is set to ${experience.trafficAllocation}.`);
+  logger.info(`The traffic random factor for experience ${experience.id} is ${trafficRandom}. It's traffic allocation is set to ${experience.trafficAllocation}.`);
   const isInTrafficRange = experience.trafficAllocation > trafficRandom;
   const matchesAudience = !experience.audience || includes(profile.audiences, experience.audience.id);
   const hasActiveExperiment = !!find(activeExperiments, {
     id: experience.id
   });
-  log(`Is the profile in traffic allocation range? ${isInTrafficRange ? 'yes' : 'no'}.\n
+  logger.info(`Is the profile in traffic allocation range? ${isInTrafficRange ? 'yes' : 'no'}.\n
       Does the profile match the audience of the experience? ${matchesAudience ? 'yes' : 'no'}.\n
       Is there an active experiment for this profile? ${hasActiveExperiment ? 'yes' : 'no'}.`);
   return isInTrafficRange && (matchesAudience || // if the expriment is active already then it's selectible without further contraints to be fullfilled
@@ -3944,7 +4115,7 @@ const selectDistribution = ({
   profile
 }) => {
   const distributionRandom = getDistributionRandom(profile, experience);
-  log(`The distribution random factor for experience ${experience.id} is ${distributionRandom}. It's distribution is set to ${JSON.stringify(experience.distribution, null, 2)}.`);
+  logger.log(`The distribution random factor for experience ${experience.id} is ${distributionRandom}. It's distribution is set to ${JSON.stringify(experience.distribution, null, 2)}.`);
   const distribution = find(experience.distribution, ({
     start,
     end
@@ -4340,4 +4511,4 @@ const decodeExperienceVariantsMap = encodedExperienceVariantsMap => {
   }), {});
 };
 
-export { index as Cache, EXPERIENCE_TRAIT_PREFIX, NINETAILED_TRACKER_EVENTS, Ninetailed, PLUGIN_NAME, decodeExperienceVariantsMap, isExperienceMatch, ninetailedPlugin, selectActiveExperiments, selectDistribution, selectEligibleExperiences, selectExperience, selectBaselineWithVariants as selectExperienceBaselineWithVariants, selectVariant as selectExperienceVariant, selectVariants as selectExperienceVariants, selectHasVariants as selectHasExperienceVariants, selectVariant$1 as selectVariant };
+export { index as Cache, EXPERIENCE_TRAIT_PREFIX, NINETAILED_TRACKER_EVENTS, Ninetailed, PLUGIN_NAME, decodeExperienceVariantsMap, isExperienceMatch, logger, ninetailedPlugin, selectActiveExperiments, selectDistribution, selectEligibleExperiences, selectExperience, selectBaselineWithVariants as selectExperienceBaselineWithVariants, selectVariant as selectExperienceVariant, selectVariants as selectExperienceVariants, selectHasVariants as selectHasExperienceVariants, selectVariant$1 as selectVariant };