feat(ga): Trace client events with ga.

Author: walkthunder

src/ga.ts

@@ -0,0 +1,100 @@
+import {v4 as uuidv4} from 'uuid';
+import { machineIdSync } from './utils/machine-id';
+let cID = machineIdSync(false);
+
+export class Analytics4 {
+    private trackingID: string;
+    private secretKey: string;
+    private clientID: string;
+    private sessionID: string;
+    private customParams: Record<string, unknown> = {};
+    private userProperties: Record<string, unknown> | null = null;
+
+    private baseURL = 'https://google-analytics.com/mp';
+    private collectURL = '/collect';
+
+    constructor(trackingID: string, secretKey: string, clientID: string = cID, sessionID = uuidv4()) {
+        this.trackingID = trackingID;
+        this.secretKey = secretKey;
+        this.clientID = clientID;
+        this.sessionID = sessionID;
+    }
+
+    set(key: string, value: any) {
+        if (value !== null) {
+            this.customParams[key] = value;
+        } else {
+            delete this.customParams[key];
+        }
+
+        return this;
+    }
+
+    setParams(params?: Record<string, unknown>) {
+        if (typeof params === 'object' && Object.keys(params).length > 0) {
+            Object.assign(this.customParams, params)
+        } else {
+            this.customParams = {};
+        }
+
+        return this;
+    }
+
+    setUserProperties(upValue?: Record<string, unknown>) {
+        if (typeof upValue === 'object' && Object.keys(upValue).length > 0) {
+            this.userProperties = upValue;
+        } else {
+            this.userProperties = null;
+        }
+
+        return this;
+    }
+
+    event(eventName: string): Promise<any> {
+        const payload = {
+            client_id: this.clientID,
+            events: [
+                {
+                    name: eventName,
+                    params: {
+                        session_id: this.sessionID,
+                        ...this.customParams,
+                    },
+                },
+            ],
+        };
+
+        if(this.userProperties) {
+            Object.assign(payload, {user_properties: this.userProperties})
+        }
+
+        return fetch(
+                `${this.baseURL}${this.collectURL}?measurement_id=${this.trackingID}&api_secret=${this.secretKey}`,
+                {
+                    method: 'POST',
+                    body: JSON.stringify(payload)
+                }
+            )
+    };
+
+    trace(eventName: string, params?: Record<string, unknown>) {
+        this.setParams();
+        this.setParams(params);
+        this.event(eventName);
+        this.setParams();
+    }
+}
+
+let gaInstance: Analytics4 = null;
+export const loadGA = () => {
+    if (gaInstance) {
+        return gaInstance;
+    }
+    gaInstance = new Analytics4('G-L8EE6ZNNG6', 's_RUrczOQYa99d7O-o8D7w');
+
+    gaInstance.setParams();
+    gaInstance.setUserProperties();
+    gaInstance.event('trace_init');
+    return gaInstance;
+}
+

src/hosting.ts

@@ -6,6 +6,7 @@ import Utils from './utils';
 import { HostServerUrl } from './remote';
 import { Notice } from "obsidian";
 import type { TransItemType } from "./i18n";
+import { loadGA } from './ga';
 // Check hosting service
 export const checkRemoteHosting = async (plugin: InvioPlugin, dirname?: string) => {
   log.info('checking remote host service info: ', dirname);
@@ -51,21 +52,34 @@ export const setupS3HostConfig = async (plugin: InvioPlugin, config: Partial<S3C
 
 export const syncWithRemoteProject = async (dirname: string, plugin: InvioPlugin) => {
   const settings = plugin.settings;
+  const ga = loadGA();
   let projectInfo = await checkRemoteHosting(plugin, dirname);
   if (!projectInfo) {
     projectInfo = await new Promise((resolve, reject) => {
       const cb = async (project: any, err?: any) => {
         log.info('project created: ', project, err);
         if (err) {
+          ga.trace('use_host_create_fail', {
+            dirname,
+            raw: err?.message || err,
+          })
           reject(err);
           return;
         }
         if (!project) {
           // Error
           log.error('create project failed: ', project);
+          ga.trace('use_host_create_fail', {
+            dirname,
+            raw: 'no project response',
+          })
           reject('Project create failed');
           return;
         }
+        ga.trace('use_host_create_done', {
+          dirname,
+          slug: project.slug,
+        })
         return resolve(project);
       };
       const modal = new CreateProjectModal(plugin.app, plugin, dirname, dirname.toLowerCase(), '', null, cb.bind(plugin));
@@ -78,6 +92,13 @@ export const syncWithRemoteProject = async (dirname: string, plugin: InvioPlugin
   }
 
   const { name, slug, password, endpoint, region, bucket, useHost: baseDomain } = projectInfo;
+  ga.trace('use_host_sync', {
+    bucket,
+    region,
+    name,
+    slug,
+    domain: baseDomain,
+  });
   settings.hostConfig.hostPair = {
     dir: name,
     password,

src/main.ts

@@ -63,6 +63,7 @@ import icon, { UsingIconNames, getIconSvg, addIconForconflictFile } from './util
 import { StatsView, VIEW_TYPE_STATS, LogType } from "./statsView";
 import { syncWithRemoteProject, switchProject } from './hosting';
 import Utils from './utils';
+import { Analytics4, loadGA } from './ga';
 
 const { iconNameSyncWait, iconNameSyncPending, iconNameSyncRunning, iconNameLogs, iconNameSyncLogo } = UsingIconNames;
 const Menu_Tab = `    `;
@@ -90,6 +91,7 @@ export default class InvioPlugin extends Plugin {
   i18n: I18n;
   vaultRandomID: string;
   recentSyncedFiles: any;
+  ga: Analytics4;
 
   isUnderWatch(file: TAbstractFile) {
     const rootDir = this.settings.localWatchDir;
@@ -154,6 +156,13 @@ export default class InvioPlugin extends Plugin {
       return;
     }
 
+    this.ga.trace('sync_run', {
+      trigger: triggerSource,
+      dirname: this.settings.localWatchDir,
+      useHost: this.settings.useHost,
+      fileNum: fileList?.length
+    });
+
     await this.checkIfRemoteProjectSync();
 
     let originLabel = `${this.manifest.name}`;
@@ -588,6 +597,12 @@ export default class InvioPlugin extends Plugin {
         }-${Date.now()}: finish sync, triggerSource=${triggerSource}`
       );
 
+      this.ga.trace('sync_run_done', {
+        trigger: triggerSource,
+        dirname: this.settings.localWatchDir,
+        useHost: this.settings.useHost,
+        fileNum: fileList?.length
+      }) 
       // TODO: Show stats model
       return toRemoteFiles;
     } catch (error) {
@@ -601,6 +616,14 @@ export default class InvioPlugin extends Plugin {
       loadingModal?.close();
       log.error(msg);
       log.error(error);
+      this.ga.trace('sync_run_err', {
+        trigger: triggerSource,
+        msg,
+        raw: error?.message,
+        dirname: this.settings.localWatchDir,
+        useHost: this.settings.useHost,
+        fileNum: fileList?.length
+      })
       getNotice(null, msg, 10 * 1000);
       if (error instanceof AggregateError) {
         for (const e of error.errors) {
@@ -626,7 +649,7 @@ export default class InvioPlugin extends Plugin {
 
   async onload() {
     log.info(`loading plugin ${this.manifest.id}`);
-  
+    this.ga = loadGA();
 		// init html generator
 		AssetHandler.initialize(this.manifest.id);
 
@@ -698,6 +721,9 @@ export default class InvioPlugin extends Plugin {
       // Add custom icon for root dir
       setTimeout(() => {
         if (this.settings.localWatchDir) {
+          this.ga.trace('boot_project', {
+            dirname: this.settings.localWatchDir
+          });
           this.switchWorkingDir(this.settings.localWatchDir);
         } else {
           new Notice(
@@ -730,6 +756,7 @@ export default class InvioPlugin extends Plugin {
                 .setTitle(`${Menu_Tab}${t('menu_set_folder')}`)
                 .setIcon("document")
                 .onClick(async () => {
+                  this.ga.trace('switch_project', { dirname: file.path });
                   await this.switchWorkingDir(file.path);
                 });
             })
@@ -748,6 +775,7 @@ export default class InvioPlugin extends Plugin {
                 .setIcon("document")
                 .onClick(async () => {
                   await InvioSettingTab.exportSettings(this)
+                  this.ga.trace('share_settings')
                 });
             })
           }
@@ -858,6 +886,10 @@ export default class InvioPlugin extends Plugin {
           if (!this.settings.useHost) {
             return;
           }
+          this.ga.trace('use_host_auth', {
+            action,
+            user
+          });
           if (!this.settings.hostConfig) {
             this.settings.hostConfig = {} as THostConfig;
           }

src/utils.ts

@@ -6,6 +6,7 @@ import os from 'os';
 import { createHash } from 'crypto';
 import { v4 } from 'uuid';
 import { AppHostServerUrl } from './remoteForS3';
+import { loadGA } from './ga';
 
 const logger = console;
 logger.info = console.log;
@@ -70,6 +71,8 @@ const showNotification = async (opt: MessageBoxOptions) => {
 
 const gotoAuth = (url?: string) => {
     (window as any).electron.remote.shell.openExternal(url || `${AppHostServerUrl}/exporter`);
+    const ga = loadGA();
+    ga?.trace('use_host_login');
 }
 
 const gotoMainSite = () => {

src/utils/machine-id.ts

@@ -0,0 +1,95 @@
+/* @flow */
+import { exec, execSync } from 'child_process';
+import { createHash } from 'crypto';
+import { nanoid } from 'nanoid'
+import {  existsSync } from 'fs';
+
+type NodeJSPlatform = 'aix' | 'darwin' | 'freebsd' | 'linux' | 'openbsd' | 'sunos' | 'win32';
+
+function parseOSFromUA(userAgent: string): NodeJSPlatform | undefined {
+    const osRegex = /(Windows NT|Mac OS X|Linux|Android|iOS|CrOS)[/ ]([\d._]+)/;
+    const match = userAgent.match(osRegex);
+  
+    if (match && match.length >= 3) {
+      const osName = match[1].toLowerCase();
+      switch (osName) {
+        case 'windows nt':
+          return 'win32';
+        case 'mac os x':
+          return 'darwin';
+        case 'linux':
+          return 'linux';
+        case 'android':
+          return 'linux';
+        case 'ios':
+          return 'darwin';
+        case 'cros':
+          return 'linux';
+        default:
+          return undefined;
+      }
+    }
+  
+    return undefined;
+  }
+
+const platform = process?.platform || parseOSFromUA(navigator.userAgent);
+console.log('get platform: ', platform);
+
+const getWin32BinPath = () => {
+    let binPath = '%windir%\\System32\\REG.exe';
+    if (!existsSync(binPath)) {
+        binPath = '%windir%\\sysnative\\cmd.exe /c %windir%\\System32\\REG.exe'
+    }
+    return binPath;
+}
+
+const guid: Record<string, string> = {
+    darwin: 'ioreg -rd1 -c IOPlatformExpertDevice',
+    win32:  getWin32BinPath() +
+        ' QUERY HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography ' +
+        '/v MachineGuid',
+    linux: '( cat /var/lib/dbus/machine-id /etc/machine-id 2> /dev/null || hostname ) | head -n 1 || :',
+    freebsd: 'kenv -q smbios.system.uuid || sysctl -n kern.hostuuid'
+};
+
+
+function hash(guid: string): string {
+    return createHash('sha256').update(guid).digest('hex');
+}
+
+function expose(result: string): string {
+    switch (platform) {
+        case 'darwin':
+            return result
+                .split('IOPlatformUUID')[1]
+                .split('\n')[0].replace(/\=|\s+|\"/ig, '')
+                .toLowerCase();
+        case 'win32':
+            return result
+                .toString()
+                .split('REG_SZ')[1]
+                .replace(/\r+|\n+|\s+/ig, '')
+                .toLowerCase();
+        case 'linux':
+            return result
+                .toString()
+                .replace(/\r+|\n+|\s+/ig, '')
+                .toLowerCase();
+        case 'freebsd':
+            return result
+                .toString()
+                .replace(/\r+|\n+|\s+/ig, '')
+                .toLowerCase();
+        default:
+            throw new Error(`Unsupported platform: ${platform}`);
+    }
+}
+
+export function machineIdSync(original: boolean): string {
+    if (!platform) {
+        return 'fakeid' + nanoid();
+    }
+    let id: string = expose(execSync(guid[platform]).toString());
+    return original ? id : hash(id);
+}