@jitsu/js 1.0.0-canary-20230211030946 → 1.0.0-canary-20230219230011

package/dist/web/p.js.txt

@@ -68,7 +68,151 @@
     return ke(_objectSpread2(_objectSpread2({}, defaultSettings), opts));
   }
 
+  var __awaiter$1 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+      return new (P || (P = Promise))(function (resolve, reject) {
+          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+          step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+  };
+  function satisfyFilter(filter, subject) {
+      return filter === "*" || filter.toLowerCase().trim() === (subject || "").trim().toLowerCase();
+  }
+  function applyFilters(event, creds) {
+      const { hosts = ["*"], events = ["*"] } = creds;
+      return (!!hosts.find(hostFilter => { var _a; return satisfyFilter(hostFilter, (_a = event.context) === null || _a === void 0 ? void 0 : _a.host); }) &&
+          !!events.find(eventFilter => satisfyFilter(eventFilter, event.type)));
+  }
+  const tagPlugin = {
+      id: "tag",
+      handle(config, payload) {
+          return __awaiter$1(this, void 0, void 0, function* () {
+              if (!applyFilters(payload, config)) {
+                  return;
+              }
+              insertTags(config.code, payload);
+          });
+      },
+  };
+  function insertTags(code, event, opts = {}) {
+      let tag;
+      try {
+          tag = JSON.parse(code);
+      }
+      catch (e) {
+          tag = { code, lang: "javascript" };
+      }
+      const debug = opts.debug || false;
+      if (isInBrowser()) {
+          if (tag.lang === "javascript") {
+              execJs(tag.code, event);
+          }
+          else {
+              const codeHolder = document.createElement("span");
+              codeHolder.innerHTML = replaceMacro(tag.code, event);
+              document.body.insertAdjacentElement("beforeend", codeHolder);
+              const scripts = codeHolder.querySelectorAll("script");
+              scripts.forEach(script => {
+                  const scriptClone = document.createElement("script");
+                  scriptClone.type = scriptClone.type || "text/javascript";
+                  if (script.hasAttribute("src")) {
+                      scriptClone.src = script.src;
+                  }
+                  scriptClone.text = script.text;
+                  if (debug) {
+                      console.log(`[JITSU] Executing script${script.hasAttribute("src") ? ` ${script.src}` : ""}`, scriptClone.text);
+                  }
+                  document.head.appendChild(scriptClone);
+                  document.head.removeChild(scriptClone);
+              });
+          }
+      }
+      else {
+          if (debug) {
+              console.log(`[JITSU] insertTags(): cannot insert tags in non-browser environment`);
+          }
+      }
+  }
+  function execJs(code, event) {
+      const varName = `jitsu_event_${randomId()}`;
+      window[varName] = event;
+      const iif = `(function(){
+      const event = ${varName};
+      ${code}
+  })()`;
+      try {
+          eval(iif);
+      }
+      catch (e) {
+          console.error(`[JITSU] Error executing JS code: ${e.message}. Code: `, iif);
+      }
+      finally {
+          delete window[varName];
+      }
+      return iif;
+  }
+  function replaceMacro(code, event) {
+      return code.replace(/{{\s*event\s*}}/g, JSON.stringify(event));
+  }
+  const internalDestinationPlugins = {
+      [tagPlugin.id]: tagPlugin,
+  };
+
+  function findScript(src) {
+      const scripts = Array.prototype.slice.call(window.document.querySelectorAll("script"));
+      return scripts.find(s => s.src === src);
+  }
+  function loadScript(src, attributes) {
+      const found = findScript(src);
+      if (found !== undefined) {
+          const status = found === null || found === void 0 ? void 0 : found.getAttribute("status");
+          if (status === "loaded") {
+              return Promise.resolve(found);
+          }
+          if (status === "loading") {
+              return new Promise((resolve, reject) => {
+                  found.addEventListener("load", () => resolve(found));
+                  found.addEventListener("error", err => reject(err));
+              });
+          }
+      }
+      return new Promise((resolve, reject) => {
+          var _a;
+          const script = window.document.createElement("script");
+          script.type = "text/javascript";
+          script.src = src;
+          script.async = true;
+          script.setAttribute("status", "loading");
+          for (const [k, v] of Object.entries(attributes !== null && attributes !== void 0 ? attributes : {})) {
+              script.setAttribute(k, v);
+          }
+          script.onload = () => {
+              script.onerror = script.onload = null;
+              script.setAttribute("status", "loaded");
+              resolve(script);
+          };
+          script.onerror = () => {
+              script.onerror = script.onload = null;
+              script.setAttribute("status", "error");
+              reject(new Error(`Failed to load ${src}`));
+          };
+          const tag = window.document.getElementsByTagName("script")[0];
+          (_a = tag.parentElement) === null || _a === void 0 ? void 0 : _a.insertBefore(script, tag);
+      });
+  }
+
   /* global analytics */
+  var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+      return new (P || (P = Promise))(function (resolve, reject) {
+          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+          step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+  };
   const config = {
       /* Your segment writeKey */
       writeKey: null,
@@ -280,7 +424,7 @@
       }, target);
   }
   function isInBrowser() {
-      return typeof document !== "undefined";
+      return typeof document !== "undefined" && typeof window !== "undefined";
   }
   function adjustPayload(payload, config, storage) {
       var _a, _b;
@@ -318,62 +462,62 @@
       delete withContext.options;
       return withContext;
   }
-  function execJs(code, event) {
-      const varName = `jitsu_event_${randomId()}`;
-      window[varName] = event;
-      const iif = `(function(){
-      ${code}
-      onEvent(${varName});
-  })()`;
-      try {
-          eval(iif);
-      }
-      catch (e) {
-          console.error(`[JITSU] Error executing JS code: ${e.message}`);
-      }
-      finally {
-          delete window[varName];
-      }
-      return iif;
-  }
-  function replaceMacro(code, event) {
-      return code.replace(/{{\s*event\s*}}/g, JSON.stringify(event));
-  }
-  function insertTags(tags, event, opts = {}) {
-      const debug = opts.debug || false;
-      if (isInBrowser()) {
-          Object.values(tags).forEach(tag => {
-              if (tag.mode === "javascript") {
-                  execJs(tag.code, event);
+  function processDestinations(destinations, method, event, debug, analyticsInstance) {
+      return __awaiter(this, void 0, void 0, function* () {
+          const promises = [];
+          for (const destination of destinations) {
+              if (destination.deviceOptions.type === "internal-plugin") {
+                  const plugin = internalDestinationPlugins[destination.deviceOptions.name];
+                  if (plugin) {
+                      try {
+                          promises.push(plugin.handle(destination.credentials, event));
+                      }
+                      catch (e) {
+                          console.warn(`[JITSU] Error processing event with internal plugin '${destination.deviceOptions.name}': ${e === null || e === void 0 ? void 0 : e.message}`, e);
+                      }
+                  }
+                  else {
+                      console.warn(`[JITSU] Unknown internal plugin '${destination.deviceOptions.name}' for destination '${destination.id}'`);
+                  }
               }
-              else {
-                  const codeHolder = document.createElement("span");
-                  codeHolder.innerHTML = replaceMacro(tag.code, event);
-                  document.body.insertAdjacentElement("beforeend", codeHolder);
-                  const scripts = codeHolder.querySelectorAll("script");
-                  scripts.forEach(script => {
-                      const scriptClone = document.createElement("script");
-                      scriptClone.type = scriptClone.type || "text/javascript";
-                      if (script.hasAttribute("src")) {
-                          scriptClone.src = script.src;
+              else if (destination.deviceOptions.type === "analytics-plugin") {
+                  yield loadScript(destination.deviceOptions.packageCdn);
+                  const plugin = window[destination.deviceOptions.moduleVarName];
+                  if (!plugin) {
+                      console.warn(`[JITSU] Broken plugin '${destination.deviceOptions.packageCdn}' for destination '${destination.id}' - it doesn't export '${destination.deviceOptions.moduleVarName}' variable`);
+                  }
+                  else {
+                      let pluginInstance;
+                      try {
+                          pluginInstance = (typeof plugin === "function" ? plugin : plugin.init)(destination.credentials);
+                      }
+                      catch (e) {
+                          console.warn(`[JITSU] Error creating plugin '${destination.deviceOptions.moduleVarName}@${destination.deviceOptions.packageCdn}' for destination '${destination.id}': ${e === null || e === void 0 ? void 0 : e.message}`, e);
+                      }
+                      try {
+                          if (debug) {
+                              console.log(`[JITSU] Plugin '${destination.deviceOptions.moduleVarName}@${destination.deviceOptions.packageCdn}' for destination '${destination.id}' initialized with config:`, pluginInstance.config);
+                          }
+                          pluginInstance.initialize({ config: pluginInstance.config, instance: analyticsInstance });
                       }
-                      scriptClone.text = script.text;
-                      if (debug) {
-                          console.log(`Executing script${script.hasAttribute("src") ? ` ${script.src}` : ""}`, scriptClone.text);
+                      catch (e) {
+                          console.warn(`[JITSU] Error initializing plugin '${destination.deviceOptions.moduleVarName}@${destination.deviceOptions.packageCdn}' for destination '${destination.id}': ${e === null || e === void 0 ? void 0 : e.message}. Config: ${JSON.stringify(pluginInstance.config)}`, e);
+                          continue;
                       }
-                      document.head.appendChild(scriptClone);
-                      document.head.removeChild(scriptClone);
-                  });
+                      if (pluginInstance[method]) {
+                          try {
+                              pluginInstance[method]({ payload: event, config: pluginInstance.config, instance: analyticsInstance });
+                          }
+                          catch (e) {
+                              console.warn(`[JITSU] Error processing ${method}() with plugin '${destination.deviceOptions.moduleVarName}@${destination.deviceOptions.packageCdn}' for destination '${destination.id}': ${e === null || e === void 0 ? void 0 : e.message}`, e);
+                          }
+                      }
+                  }
               }
-          });
-      }
-      else {
-          if (debug) {
-              console.log(`insertTags: cannot insert tags in non-browser environment`);
           }
-      }
+      });
   }
-  function send(method, payload, jitsuConfig, store) {
+  function send(method, payload, jitsuConfig, instance, store) {
       if (jitsuConfig.echoEvents) {
           console.log(`[JITSU] sending '${method}' event:`, payload);
           return;
@@ -406,18 +550,19 @@
           }
       })
           .then(responseText => {
+          let response;
           try {
-              const response = JSON.parse(responseText);
-              if (response.tags) {
-                  if (jitsuConfig.debug) {
-                      console.log(`[JITSU] Response Tags: `, JSON.stringify(response.tags, null, 2));
-                  }
-                  insertTags(response.tags, payload, { debug: jitsuConfig.debug });
-              }
+              response = JSON.parse(responseText);
           }
           catch (e) {
               return Promise.reject(`Can't parse JSON: ${responseText}: ${e === null || e === void 0 ? void 0 : e.message}`);
           }
+          if (response.destinations) {
+              if (jitsuConfig.debug) {
+                  console.log(`[JITSU] Processing device destianations: `, JSON.stringify(response.destinations, null, 2));
+              }
+              return processDestinations(response.destinations, method, adjustedPayload, !!jitsuConfig.debug, instance);
+          }
       })
           .catch(err => {
           if (jitsuConfig.debug) {
@@ -447,9 +592,9 @@
           name: "jitsu",
           config: Object.assign(Object.assign({}, config), pluginConfig),
           initialize: args => {
-              const { config, instance } = args;
+              const { config } = args;
               if (config.debug) {
-                  console.debug("Initializing Jitsu plugin with config: ", JSON.stringify(config));
+                  console.debug("[JITSU] Initializing Jitsu plugin with config: ", JSON.stringify(config));
               }
               if (!config.host && !config.echoEvents) {
                   throw new Error("Please specify host variable in jitsu plugin initialization, or set echoEvents to true");
@@ -457,17 +602,17 @@
           },
           page: args => {
               const { payload, config, instance } = args;
-              return send("page", payload, config, cachingStorageWrapper(instance.storage));
+              return send("page", payload, config, instance, cachingStorageWrapper(instance.storage));
           },
           track: args => {
               const { payload, config, instance } = args;
-              return send("track", payload, config, cachingStorageWrapper(instance.storage));
+              return send("track", payload, config, instance, cachingStorageWrapper(instance.storage));
           },
           identify: args => {
               const { payload, config, instance } = args;
               // Store traits in cache to be able to use them in page and track events that run asynchronously with current identify.
               storageCache["__user_traits"] = payload.traits;
-              return send("identify", payload, config, cachingStorageWrapper(instance.storage));
+              return send("identify", payload, config, instance, cachingStorageWrapper(instance.storage));
           },
           reset: args => {
               //clear storage cache
@@ -520,13 +665,12 @@
       }
       return value;
   }
-  function jitsuAnalytics(opts) {
-      const rt = opts.runtime || (typeof window === "undefined" ? emptyRuntime(opts) : windowRuntime(opts));
+  function createUnderlyingAnalyticsInstance(opts, rt, plugins = []) {
       const analytics = analyticsLib({
           app: "test",
           debug: !!opts.debug,
           storage: rt.store(),
-          plugins: [jitsuAnalyticsPlugin(opts)],
+          plugins: [jitsuAnalyticsPlugin(opts), ...plugins],
       });
       const originalPage = analytics.page;
       analytics.page = (...args) => {
@@ -539,6 +683,33 @@
       };
       return analytics;
   }
+  function jitsuAnalytics(opts) {
+      const inBrowser = isInBrowser();
+      const rt = opts.runtime || (inBrowser ? windowRuntime(opts) : emptyRuntime(opts));
+      return createUnderlyingAnalyticsInstance(opts, rt);
+      // if (inBrowser) {
+      //   const fetch = opts.fetch || globalThis.fetch;
+      //   if (!fetch) {
+      //     throw new Error(
+      //       "Please specify fetch function in jitsu plugin initialization, fetch isn't available in global scope"
+      //     );
+      //   }
+      //   const url = `${opts.host}/api/s/cfg`;
+      //   const authHeader = {};
+      //   const debugHeader = opts.debug ? { "X-Enable-Debug": "true" } : {};
+      //   fetch(url)
+      //     .then(res => res.json())
+      //     .then(res => {
+      //       result.loaded(createUnderlyingAnalyticsInstance(opts, rt, []));
+      //     })
+      //     .catch(e => {
+      //       console.warn(`[JITSU] error getting device-destinations from ${url}`, e);
+      //       result.loaded(createUnderlyingAnalyticsInstance(opts, rt));
+      //     });
+      // } else {
+      //   result.loaded(createUnderlyingAnalyticsInstance(opts, rt));
+      // }
+  }
 
   function snakeToCamel(s) {
       return s.replace(/([-_][a-z])/gi, $1 => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jitsu/js",
-  "version": "1.0.0-canary-20230211030946",
+  "version": "1.0.0-canary-20230219230011",
   "description": "",
   "author": "Jitsu Dev Team <dev@jitsu.com>",
   "main": "dist/jitsu.cjs.js",
@@ -12,7 +12,7 @@
   "license": "MIT",
   "private": false,
   "devDependencies": {
-    "@playwright/test": "^1.28.1",
+    "@playwright/test": "^1.30.0",
     "@rollup/plugin-commonjs": "^23.0.2",
     "@rollup/plugin-json": "^5.0.1",
     "@rollup/plugin-multi-entry": "^6.0.0",
@@ -35,8 +35,8 @@
     "ts-jest": "^29.0.3"
   },
   "dependencies": {
-    "@jitsu/protocols": "0.0.0",
-    "analytics": "^0.8.1"
+    "analytics": "^0.8.1",
+    "@jitsu/protocols": "0.0.0"
   },
   "scripts": {
     "clean": "rm -rf ./dist",

package/src/analytics-plugin.ts

@@ -3,7 +3,9 @@
 import { JitsuOptions, PersistentStorage, RuntimeFacade } from "./jitsu";
 import { AnalyticsClientEvent } from "@jitsu/protocols/analytics";
 import parse from "./index";
-import { AnalyticsPlugin } from "analytics";
+import { AnalyticsInstance, AnalyticsPlugin } from "analytics";
+import { internalDestinationPlugins } from "./destination-plugins";
+import { loadScript } from "./script-loader";
 
 const config: JitsuOptions = {
   /* Your segment writeKey */
@@ -238,8 +240,8 @@ function deepMerge(target: any, source: any) {
   }, target);
 }
 
-function isInBrowser() {
-  return typeof document !== "undefined";
+export function isInBrowser() {
+  return typeof document !== "undefined" && typeof window !== "undefined";
 }
 
 function adjustPayload(payload: any, config: JitsuOptions, storage: PersistentStorage): AnalyticsClientEvent {
@@ -285,65 +287,107 @@ function adjustPayload(payload: any, config: JitsuOptions, storage: PersistentSt
   return withContext;
 }
 
-function execJs(code: string, event: any) {
-  const varName = `jitsu_event_${randomId()}`;
-  window[varName] = event;
-  const iif = `(function(){
-      ${code}
-      onEvent(${varName});
-  })()`;
-  try {
-    eval(iif);
-  } catch (e) {
-    console.error(`[JITSU] Error executing JS code: ${e.message}`);
-  } finally {
-    delete window[varName];
-  }
-  return iif;
-}
+export type DestinationDescriptor = {
+  id: string;
+  destinationType: string;
+  credentials: any;
+  deviceOptions: DeviceOptions;
+};
+export type AnalyticsPluginDescriptor = {
+  type: "analytics-plugin";
+  packageCdn: string;
+  moduleVarName: string;
+};
 
-function replaceMacro(code, event) {
-  return code.replace(/{{\s*event\s*}}/g, JSON.stringify(event));
-}
+export type InternalPluginDescriptor = {
+  type: "internal-plugin";
+  name: string;
+};
+
+export type DeviceOptions = AnalyticsPluginDescriptor | InternalPluginDescriptor;
 
-function insertTags(
-  tags: Record<string, { mode: "javascript" | "html"; code }>,
-  event: any,
-  opts: { debug?: boolean } = {}
+async function processDestinations(
+  destinations: DestinationDescriptor[],
+  method: string,
+  event: AnalyticsClientEvent,
+  debug: boolean,
+  analyticsInstance: AnalyticsInstance
 ) {
-  const debug = opts.debug || false;
-  if (isInBrowser()) {
-    Object.values(tags).forEach(tag => {
-      if (tag.mode === "javascript") {
-        execJs(tag.code, event);
+  const promises: Promise<any>[] = [];
+  for (const destination of destinations) {
+    if (destination.deviceOptions.type === "internal-plugin") {
+      const plugin = internalDestinationPlugins[destination.deviceOptions.name];
+      if (plugin) {
+        try {
+          promises.push(plugin.handle(destination.credentials, event));
+        } catch (e) {
+          console.warn(
+            `[JITSU] Error processing event with internal plugin '${destination.deviceOptions.name}': ${e?.message}`,
+            e
+          );
+        }
       } else {
-        const codeHolder = document.createElement("span");
-        codeHolder.innerHTML = replaceMacro(tag.code, event);
-        document.body.insertAdjacentElement("beforeend", codeHolder);
-        const scripts = codeHolder.querySelectorAll("script");
-        scripts.forEach(script => {
-          const scriptClone = document.createElement("script");
-          scriptClone.type = scriptClone.type || "text/javascript";
-          if (script.hasAttribute("src")) {
-            scriptClone.src = script.src;
-          }
-          scriptClone.text = script.text;
+        console.warn(
+          `[JITSU] Unknown internal plugin '${destination.deviceOptions.name}' for destination '${destination.id}'`
+        );
+      }
+    } else if (destination.deviceOptions.type === "analytics-plugin") {
+      await loadScript(destination.deviceOptions.packageCdn);
+      const plugin = window[destination.deviceOptions.moduleVarName];
+      if (!plugin) {
+        console.warn(
+          `[JITSU] Broken plugin '${destination.deviceOptions.packageCdn}' for destination '${destination.id}' - it doesn't export '${destination.deviceOptions.moduleVarName}' variable`
+        );
+      } else {
+        let pluginInstance: any;
+        try {
+          pluginInstance = (typeof plugin === "function" ? plugin : plugin.init)(destination.credentials);
+        } catch (e) {
+          console.warn(
+            `[JITSU] Error creating plugin '${destination.deviceOptions.moduleVarName}@${destination.deviceOptions.packageCdn}' for destination '${destination.id}': ${e?.message}`,
+            e
+          );
+        }
+        try {
           if (debug) {
-            console.log(`Executing script${script.hasAttribute("src") ? ` ${script.src}` : ""}`, scriptClone.text);
+            console.log(
+              `[JITSU] Plugin '${destination.deviceOptions.moduleVarName}@${destination.deviceOptions.packageCdn}' for destination '${destination.id}' initialized with config:`,
+              pluginInstance.config
+            );
           }
-          document.head.appendChild(scriptClone);
-          document.head.removeChild(scriptClone);
-        });
+          pluginInstance.initialize({ config: pluginInstance.config, instance: analyticsInstance });
+        } catch (e) {
+          console.warn(
+            `[JITSU] Error initializing plugin '${destination.deviceOptions.moduleVarName}@${
+              destination.deviceOptions.packageCdn
+            }' for destination '${destination.id}': ${e?.message}. Config: ${JSON.stringify(pluginInstance.config)}`,
+            e
+          );
+          continue;
+        }
+
+        if (pluginInstance[method]) {
+          try {
+            pluginInstance[method]({ payload: event, config: pluginInstance.config, instance: analyticsInstance });
+          } catch (e) {
+            console.warn(
+              `[JITSU] Error processing ${method}() with plugin '${destination.deviceOptions.moduleVarName}@${destination.deviceOptions.packageCdn}' for destination '${destination.id}': ${e?.message}`,
+              e
+            );
+          }
+        }
       }
-    });
-  } else {
-    if (debug) {
-      console.log(`insertTags: cannot insert tags in non-browser environment`);
     }
   }
 }
 
-function send(method, payload, jitsuConfig: Required<JitsuOptions>, store: PersistentStorage): Promise<void> {
+function send(
+  method,
+  payload,
+  jitsuConfig: Required<JitsuOptions>,
+  instance: AnalyticsInstance,
+  store: PersistentStorage
+): Promise<void> {
   if (jitsuConfig.echoEvents) {
     console.log(`[JITSU] sending '${method}' event:`, payload);
     return;
@@ -387,17 +431,18 @@ function send(method, payload, jitsuConfig: Required<JitsuOptions>, store: Persi
       }
     })
     .then(responseText => {
+      let response: any;
       try {
-        const response = JSON.parse(responseText);
-        if (response.tags) {
-          if (jitsuConfig.debug) {
-            console.log(`[JITSU] Response Tags: `, JSON.stringify(response.tags, null, 2));
-          }
-          insertTags(response.tags, payload, { debug: jitsuConfig.debug });
-        }
+        response = JSON.parse(responseText);
       } catch (e) {
         return Promise.reject(`Can't parse JSON: ${responseText}: ${e?.message}`);
       }
+      if (response.destinations) {
+        if (jitsuConfig.debug) {
+          console.log(`[JITSU] Processing device destianations: `, JSON.stringify(response.destinations, null, 2));
+        }
+        return processDestinations(response.destinations, method, adjustedPayload, !!jitsuConfig.debug, instance);
+      }
     })
     .catch(err => {
       if (jitsuConfig.debug) {
@@ -431,9 +476,9 @@ const jitsuAnalyticsPlugin = (pluginConfig: JitsuOptions = {}): AnalyticsPlugin
       ...pluginConfig,
     },
     initialize: args => {
-      const { config, instance } = args;
+      const { config } = args;
       if (config.debug) {
-        console.debug("Initializing Jitsu plugin with config: ", JSON.stringify(config));
+        console.debug("[JITSU] Initializing Jitsu plugin with config: ", JSON.stringify(config));
       }
       if (!config.host && !config.echoEvents) {
         throw new Error("Please specify host variable in jitsu plugin initialization, or set echoEvents to true");
@@ -441,17 +486,17 @@ const jitsuAnalyticsPlugin = (pluginConfig: JitsuOptions = {}): AnalyticsPlugin
     },
     page: args => {
       const { payload, config, instance } = args;
-      return send("page", payload, config, cachingStorageWrapper(instance.storage));
+      return send("page", payload, config, instance, cachingStorageWrapper(instance.storage));
     },
     track: args => {
       const { payload, config, instance } = args;
-      return send("track", payload, config, cachingStorageWrapper(instance.storage));
+      return send("track", payload, config, instance, cachingStorageWrapper(instance.storage));
     },
     identify: args => {
       const { payload, config, instance } = args;
       // Store traits in cache to be able to use them in page and track events that run asynchronously with current identify.
       storageCache["__user_traits"] = payload.traits;
-      return send("identify", payload, config, cachingStorageWrapper(instance.storage));
+      return send("identify", payload, config, instance, cachingStorageWrapper(instance.storage));
     },
     reset: args => {
       //clear storage cache