fix: setAnonumousId() fixed in @jitsu/js. Fixes GH #1060

libs/jitsu-js/__tests__/node/nodejs.test.ts

@@ -11,6 +11,7 @@ describe("Test Jitsu NodeJS client", () => {
   let requestLog: { type: string; body: AnalyticsClientEvent }[] = [];
 
   const startServer = async () => {
+    requestLog = [];
     server = await createServer({
       port: 3088,
       https: false,
@@ -30,8 +31,45 @@ describe("Test Jitsu NodeJS client", () => {
   const shutdownServer = async () => {
     console.log("Shutting down server " + server.baseUrl);
     await server.close();
+    console.log("Server is down " + server.baseUrl);
   };
 
+  test("setAnonymousId test2", async () => {
+    await startServer();
+
+    const config = {
+      host: server.baseUrl,
+      writeKey: "key:secret",
+      debug: true,
+    };
+
+    try {
+      console.log("[JITSU TEST] Initializing Jitsu");
+      const client = jitsuAnalytics(config);
+      console.log("[JITSU TEST] Jitsu instance", client);
+
+      const anonymousId = "anonymous_id_test";
+      console.log("[JITSU TEST] Setting anonymous id to " + anonymousId);
+      await client.setAnonymousId(anonymousId);
+      console.log("user state", client.getState("user"));
+
+      expect(requestLog.length).toBe(0);
+      console.log("[JITSU TEST] Sending event EVENT_1");
+      await client.track("EVENT_1");
+      await client.track("EVENT_2");
+      await client.track("groupId");
+
+      await new Promise(resolve => setTimeout(resolve, 1000));
+
+      expect(requestLog.length).toBe(3);
+      expect(requestLog[1].body.anonymousId).toBe("anonymous_id_test");
+      expect(requestLog[0].body.anonymousId).toBe("anonymous_id_test");
+      expect(requestLog[2].body.anonymousId).toBe("anonymous_id_test");
+    } finally {
+      shutdownServer();
+    }
+  });
+
   test("node js", async () => {
     await startServer();
     try {

libs/jitsu-js/package.json

@@ -45,6 +45,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "analytics": "^0.8.1"
+    "analytics": "0.8.9"
   }
 }

libs/jitsu-js/rollup.config.js

@@ -4,9 +4,16 @@ const commonjs = require("@rollup/plugin-commonjs");
 const rollupJson = require("@rollup/plugin-json");
 const terser = require("@rollup/plugin-terser");
 
+
 module.exports = [
   {
-    plugins: [multi(), resolve({ preferBuiltins: false }), commonjs(), rollupJson(), terser()],
+    plugins: [
+      multi(),
+      resolve({ preferBuiltins: false }),
+      commonjs(),
+      rollupJson(),
+      (process.JITSU_JS_DEBUG_BUILD = "1" ? undefined : terser()),
+    ],
     input: "./compiled/src/browser.js",
     output: {
       file: `dist/web/p.js.txt`,

libs/jitsu-js/src/analytics-plugin.ts

@@ -479,7 +479,7 @@ function send(
   store: PersistentStorage
 ): Promise<void> {
   if (jitsuConfig.echoEvents) {
-    console.log(`[JITSU] sending '${method}' event:`, payload);
+    console.log(`[JITSU DEBUG] sending '${method}' event:`, payload);
     return;
   }
 
@@ -545,18 +545,31 @@ function send(
 
 const jitsuAnalyticsPlugin = (pluginConfig: JitsuOptions = {}): AnalyticsPlugin => {
   const storageCache: any = {};
+
   // AnalyticsInstance's storage is async somewhere inside. So if we make 'page' call right after 'identify' call
   // 'page' call will load traits from storage before 'identify' call had a change to save them.
   // to avoid that we use in-memory cache for storage
   const cachingStorageWrapper = (persistentStorage: PersistentStorage): PersistentStorage => ({
     setItem(key: string, val: any) {
+      if (pluginConfig.debug) {
+        console.log(`[JITSU DEBUG] Caching storage setItem: ${key}=${val}`);
+      }
       storageCache[key] = val;
       persistentStorage.setItem(key, val);
     },
     getItem(key: string) {
-      return storageCache[key] || persistentStorage.getItem(key);
+      const value = storageCache[key] || persistentStorage.getItem(key);
+      if (pluginConfig.debug) {
+        console.log(
+          `[JITSU DEBUG] Caching storage getItem: ${key}=${value}. Evicted from cache: ${!storageCache[key]}`
+        );
+      }
+      return value;
     },
     removeItem(key: string) {
+      if (pluginConfig.debug) {
+        console.log(`[JITSU DEBUG] Caching storage removeItem: ${key}`);
+      }
       delete storageCache[key];
       persistentStorage.removeItem(key);
     },
@@ -568,10 +581,11 @@ const jitsuAnalyticsPlugin = (pluginConfig: JitsuOptions = {}): AnalyticsPlugin
   return {
     name: "jitsu",
     config: instanceConfig,
+
     initialize: args => {
       const { config } = args;
       if (config.debug) {
-        console.debug("[JITSU] Initializing Jitsu plugin with config: ", JSON.stringify(config));
+        console.debug("[JITSU DEBUG] Initializing Jitsu plugin with config: ", JSON.stringify(config, null, 2));
       }
       if (!config.host && !config.echoEvents) {
         throw new Error("Please specify host variable in jitsu plugin initialization, or set echoEvents to true");
@@ -600,15 +614,16 @@ const jitsuAnalyticsPlugin = (pluginConfig: JitsuOptions = {}): AnalyticsPlugin
       //analytics doesn't support group as a base method, so we need to add it manually
       group(groupId?: ID, traits?: JSONObject | null, options?: Options, callback?: Callback) {
         const analyticsInstance = this.instance;
+        const cacheWrap = cachingStorageWrapper(analyticsInstance.storage);
         const user = analyticsInstance.user();
         const userId = options?.userId || user?.userId;
-        const anonymousId = options?.anonymousId || user?.anonymousId;
+        const anonymousId = options?.anonymousId || user?.anonymousId || cacheWrap.getItem("__anon_id");
         return send(
           "group",
           { type: "group", groupId, traits, ...(anonymousId ? { anonymousId } : {}), ...(userId ? { userId } : {}) },
           instanceConfig,
           analyticsInstance,
-          cachingStorageWrapper(analyticsInstance.storage)
+          cacheWrap
         );
       },
     },

libs/jitsu-js/src/index.ts

@@ -23,7 +23,8 @@ export default function parse(input) {
   return value;
 }
 
-export const emptyAnalytics = {
+export const emptyAnalytics: AnalyticsInterface = {
+  setAnonymousId: () => {},
   track: () => Promise.resolve(),
   page: () => Promise.resolve(),
   user: () => ({}),
@@ -37,10 +38,11 @@ function createUnderlyingAnalyticsInstance(
   rt: RuntimeFacade,
   plugins: any[] = []
 ): AnalyticsInterface {
+  const storage = rt.store();
   const analytics = Analytics({
     app: "test",
     debug: !!opts.debug,
-    storage: rt.store(),
+    storage,
     plugins: [jitsuAnalyticsPlugin(opts), ...plugins],
   } as any);
   const originalPage = analytics.page;
@@ -56,6 +58,19 @@ function createUnderlyingAnalyticsInstance(
   };
   return {
     ...analytics,
+    setAnonymousId: (id: string) => {
+      if (opts.debug) {
+        console.log("[JITSU DEBUG] Setting anonymous id to " + id);
+        //Workaround for analytics.js bug. Underlying setAnonymousId doesn't work set the id immediately,
+        //so we got to it manually here. See https://github.com/jitsucom/jitsu/issues/1060
+        storage.setItem("__anon_id", id);
+        const userState = analytics.user();
+        if (userState) {
+          userState.anonymousId = id;
+        }
+        (analytics as any).setAnonymousId(id);
+      }
+    },
     group(groupId?: ID, traits?: JSONObject | null, options?: Options, callback?: Callback): Promise<DispatchedEvent> {
       for (const plugin of Object.values(analytics.plugins)) {
         if (plugin["group"]) {

types/protocols/analytics.d.ts

@@ -199,6 +199,8 @@ export interface AnalyticsInterface {
 
   user(): any;
 
+  setAnonymousId(id: string): void;
+
   // alias(
   //   to: string | number,
   //   from?: string | number | Options,