gio-miniprogram-sdk 4.0.0 → 4.1.0

package/src/core/pluginsInstance/base.ts

@@ -0,0 +1,157 @@
+// 原生环境下的plugin实例，无任何内置插件
+import { GrowingIOType } from '@@/types/growingIO';
+import { PluginItem, PluginsType } from '@@/types/plugins';
+import {
+  find,
+  isEmpty,
+  isFunction,
+  keys,
+  lowerFirst,
+  unset
+} from '@@/utils/glodash';
+import { consoleText } from '@@/utils/tools';
+import EMIT_MSG from '@@/constants/emitMsg';
+
+// 会被强制剔除出内置的插件（即必须通过手动注册的方式加载的内置插件）
+const EXTRA_PLUGINS = ['gioPerformance'];
+// @ts-nocheck
+class BasePlugins implements PluginsType {
+  public pluginItems: PluginItem[];
+  public pluginsContext: any;
+  constructor(public growingIO: GrowingIOType) {
+    this.pluginsContext = { plugins: {} };
+    this.pluginItems = [];
+    this.growingIO.emitter?.on(EMIT_MSG.ON_INSTALL, (args) =>
+      this.callLifeCycle('onInstall', args)
+    );
+    this.growingIO.emitter?.on(EMIT_MSG.ON_ERROR, (args) =>
+      this.callLifeCycle('onError', args)
+    );
+    this.growingIO.emitter?.on(EMIT_MSG.ON_COMPOSE_BEFORE, (args) =>
+      this.callLifeCycle('onComposeBefore', args)
+    );
+    this.growingIO.emitter?.on(EMIT_MSG.ON_COMPOSE_AFTER, (args) =>
+      this.callLifeCycle('onComposeAfter', args)
+    );
+    this.growingIO.emitter?.on(EMIT_MSG.ON_SEND_BEFORE, (args) =>
+      this.callLifeCycle('onSendBefore', args)
+    );
+    this.growingIO.emitter?.on(EMIT_MSG.ON_SEND_AFTER, (args) =>
+      this.callLifeCycle('onSendAfter', args)
+    );
+  }
+
+  // 初始化内置插件，不允许客户自己热插拔的插件，内置打包完成
+  innerPluginInit = () => {
+    EXTRA_PLUGINS.forEach((o) => unset(this.pluginsContext?.plugins, o));
+    keys(this.pluginsContext?.plugins).forEach((key) => {
+      const { name, method }: PluginItem =
+        this.pluginsContext?.plugins[key] ?? {};
+      // 若列表中出现同名插件，以第一个扫描出来的插件为准
+      const isExist = find(this.pluginItems, (o) => o.name === name);
+      if (!isExist) {
+        this.pluginItems.push({
+          // 优先使用指定插件名
+          name: lowerFirst(name || key),
+          method: method ? method : (growingIO) => {} // eslint-disable-line
+        });
+      }
+    });
+    if (!isEmpty(this.pluginItems)) {
+      this.installAll();
+    }
+  };
+
+  // 挂载插件
+  install = (pluginName: string, pluginItem?: any, options?: any) => {
+    const { emitter } = this.growingIO;
+    const pluginTarget: PluginItem =
+      pluginItem ||
+      find(this.pluginItems, (o: PluginItem) => o.name === pluginName);
+    // 插件已加载或与已加载的插件重名
+    if ((this.growingIO?.plugins as any)[pluginName]) {
+      consoleText(`重复加载插件 ${pluginName} 或插件重名，已跳过加载!`, 'warn');
+      return false;
+    }
+    // 插件列表中不存在要加载的插件
+    if (!pluginTarget) {
+      consoleText(`插件加载失败!不存在名为 ${pluginName} 的插件!`, 'error');
+      return false;
+    }
+    // 将插件实例挂载到growingIO实例上使得其他模块可以调用
+    try {
+      (this.growingIO?.plugins as any)[pluginName] = new (
+        pluginTarget as any
+      ).method(this.growingIO, options);
+      if (pluginItem) {
+        emitter.emit(EMIT_MSG.ON_INSTALL, pluginName);
+        consoleText(`加载插件 ${pluginName}`, 'info');
+      }
+      return true;
+    } catch (error) {
+      this.lifeError(pluginItem, error);
+      consoleText(`插件【${pluginName}】加载异常 ${error}`, 'error');
+      return false;
+    }
+  };
+
+  // 挂载所有插件
+  installAll = (plugins?: PluginItem[]) => {
+    (plugins || this.pluginItems).forEach((o: PluginItem) => {
+      const suc = this.install(
+        o.name,
+        plugins ? o : undefined,
+        plugins ? o?.options : undefined
+      );
+      if (suc && !find(this.pluginItems, (p) => p.name === o.name)) {
+        this.pluginItems.push({
+          // 优先使用指定插件名
+          name: lowerFirst(o.name),
+          // @ts-ignore
+          method: o.method ? o.method : () => {}
+        });
+      }
+    });
+  };
+
+  // 移除插件
+  uninstall = (pluginName: string) => {
+    unset(this.pluginItems, pluginName);
+    const u = unset(this.growingIO?.plugins, pluginName);
+    if (!u) {
+      consoleText(`卸载插件 ${pluginName} 失败!`, 'error');
+    }
+    return u as boolean;
+  };
+
+  // 移除所有插件
+  uninstallAll = () => {
+    this.pluginItems.forEach((o: PluginItem) => this.uninstall(o.name));
+  };
+
+  lifeError = (p: PluginItem, e: any) => {
+    this.growingIO.emitter.emit(EMIT_MSG.ON_ERROR, {
+      plugin: p,
+      error: e
+    });
+    consoleText(`插件执行错误 ${p.name} ${e}`, 'error');
+  };
+
+  // 触发插件的生命周期事件
+  callLifeCycle = (lifetime: string, args: any) => {
+    this.pluginItems.forEach((o: PluginItem) => {
+      const method = (this.growingIO.plugins as any)[o.name]
+        ? (this.growingIO.plugins as any)[o.name][lifetime]
+        : undefined;
+      if (method && isFunction(method)) {
+        try {
+          method(args);
+        } catch (e) {
+          this.lifeError(o, e);
+        }
+      }
+    });
+  };
+}
+
+export default BasePlugins;

package/src/core/pluginsInstance/taro.ts

@@ -0,0 +1,15 @@
+// taro环境下的plugins实例，添加taro适配插件
+import { GrowingIOType } from '@@/types/growingIO';
+import BasePlugins from './base';
+import gioTaroAdapter from '@@/adapters/gioTaroAdapter';
+
+class Plugins extends BasePlugins {
+  constructor(public growingIO: GrowingIOType) {
+    super(growingIO);
+    this.pluginsContext = {
+      plugins: { gioTaroAdapter }
+    };
+  }
+}
+
+export default Plugins;

package/src/core/pluginsInstance/tb.ts

@@ -0,0 +1,15 @@
+// taobao环境下的plugins实例，添加taobao适配插件
+import { GrowingIOType } from '@@/types/growingIO';
+import BasePlugins from './base';
+import gioTaobaoAdapter from '@@/adapters/gioTaobaoAdapter';
+
+class Plugins extends BasePlugins {
+  constructor(public growingIO: GrowingIOType) {
+    super(growingIO);
+    this.pluginsContext = {
+      plugins: { gioTaobaoAdapter }
+    };
+  }
+}
+
+export default Plugins;

package/src/core/pluginsInstance/uniapp.ts

@@ -0,0 +1,15 @@
+// uniapp环境下的plugins实例，添加uniapp适配插件
+import { GrowingIOType } from '@@/types/growingIO';
+import BasePlugins from './base';
+import gioUniAppAdapter from '@@/adapters/gioUniAppAdapter';
+
+class Plugins extends BasePlugins {
+  constructor(public growingIO: GrowingIOType) {
+    super(growingIO);
+    this.pluginsContext = {
+      plugins: { gioUniAppAdapter }
+    };
+  }
+}
+
+export default Plugins;

package/src/core/uploader.ts

@@ -1,49 +1,62 @@
 import {
-  endsWith,
-  isArray,
+  head,
   isEmpty,
+  isNil,
   startsWith,
   throttle,
-  toString,
   unset
 } from '@@/utils/glodash';
-import { Event } from '@@/types/base';
+import { EVENT, EXTEND_EVENT } from '@@/types/base';
 import { consoleText } from '@@/utils/tools';
 import { GrowingIOType } from '@@/types/growingIO';
 import { UploaderType } from '@@/types/uploader';
+import EMIT_MSG from '@@/constants/emitMsg';
 
 class Uploader implements UploaderType {
   // 因forceLogin配置积压的事件请求队列
-  public hoardingQueue: any[];
+  public hoardingQueue: any;
   // 请求队列
-  public requestQueue: any[];
+  public requestQueue: any;
   // 请求限制最大数
   public requestLimit: number;
-  // 请求超时时间(ms)
-  public requestTimeout: number;
   // 请求重试限制最大数
   public retryLimit: number;
   // 请求重试的原请求id
   public retryIds: any;
   // 请求中的请求数
   public requestingNum: number;
-  // 请求地址
-  public requestURL: string;
 
   constructor(public growingIO: GrowingIOType) {
-    this.hoardingQueue = [];
-    this.requestQueue = [];
+    this.hoardingQueue = {};
+    this.requestQueue = {};
     this.requestLimit = 3;
-    this.requestTimeout = 5000;
     this.retryLimit = 2;
     this.retryIds = {};
     this.requestingNum = 0;
-    this.requestURL = this.generateURL();
+    const { emitter, vdsConfig, plugins } = this.growingIO;
+    emitter.on(
+      EMIT_MSG.ON_SEND_BEFORE,
+      ({ eventsQueue, requestData, trackingId }) => {
+        // 核心逻辑中只发送主实例的事件
+        if (trackingId === this.growingIO.trackingId) {
+          if (vdsConfig?.tbConfig?.cloudAppId) {
+            // 通过淘宝云应用转发
+            plugins?.gioTaobaoAdapter?.tbCloudAppInvoke(
+              eventsQueue,
+              requestData
+            );
+          } else {
+            this.sendEvent(eventsQueue, requestData);
+          }
+        }
+      }
+    );
   }
 
   // 生成上报地址
-  generateURL = () => {
-    const { serverUrl, projectId } = this.growingIO.vdsConfig;
+  generateURL = (trackingId: string) => {
+    const { serverUrl, projectId } =
+      this.growingIO.dataStore.getTrackerVds(trackingId);
     if (!startsWith(serverUrl, 'http')) {
       return `https://${serverUrl}/v3/projects/${projectId}/collect`;
     } else {
@@ -51,70 +64,114 @@ class Uploader implements UploaderType {
     }
   };
 
+  // 获取积压队列
+  getHoardingQueue = (trackingId: string) =>
+    this.hoardingQueue[trackingId] ?? [];
+
+  // 获取请求队列
+  getRequestQueue = (trackingId: string) => this.requestQueue[trackingId] ?? [];
+
   // 提交请求（将请求按队列进行管理）
-  commitRequest = (reqData: Event) => {
-    const data: Event = { ...reqData };
-    const { vdsConfig } = this.growingIO;
+  commitRequest = (commitData: EXTEND_EVENT) => {
+    const data: EXTEND_EVENT = { ...commitData };
+    const { vdsConfig, emitter } = this.growingIO;
+    emitter.emit(EMIT_MSG.ON_COMMIT_REQUEST, {
+      eventData: commitData,
+      trackingId: commitData.trackingId
+    });
     // 如果开启forceLogin 则将请求推入积压队列，反之则进入请求队列
     if (vdsConfig.forceLogin) {
-      this.hoardingQueue.push(data);
+      if (isNil(this.hoardingQueue[commitData.trackingId])) {
+        this.hoardingQueue[commitData.trackingId] = [];
+      }
+      this.hoardingQueue[commitData.trackingId]?.push(data);
     } else {
-      this.requestQueue.push(data);
-      this.initiateRequest();
+      if (isNil(this.requestQueue[commitData.trackingId])) {
+        this.requestQueue[commitData.trackingId] = [];
+      }
+      this.requestQueue[commitData.trackingId]?.push(data);
+      this.initiateRequest(commitData.trackingId);
     }
   };
 
   // 发起请求
-  initiateRequest = (forceSend?: boolean) => {
-    const { plugins, vdsConfig } = this.growingIO;
+  initiateRequest = (trackingId: string, forceSend?: boolean) => {
+    const { plugins, vdsConfig, minipInstance, dataStore } = this.growingIO;
+    const hoardingQueue = this.getHoardingQueue(trackingId);
+    const requestQueue = this.getRequestQueue(trackingId);
     // 同时请求数的限制，防止挤占小程序本身的业务请求
-    if (
-      [...this.hoardingQueue, ...this.requestQueue].length > 0 &&
-      this.requestingNum < this.requestLimit
-    ) {
-      // 淘宝云函数单发判断
+    const queues = [...hoardingQueue, ...requestQueue];
+    const requestProcess = (tid: string) => {
+      // 淘宝云函数直接发送要单发
       if (vdsConfig?.tbConfig?.cloudFuncSend) {
-        plugins?.gioTaobaoAdapter?.singleInvoke();
+        plugins?.gioTaobaoAdapter?.singleInvoke(tid);
       } else if (forceSend) {
-        this.batchInvoke();
+        // 强制即时发送
+        this.batchInvoke(tid);
+      } else {
+        // 有节流的批量发送(1秒钟之内产生的请求只会组团发送一次)
+        const { uploadInterval } = this.growingIO.dataStore.getTrackerVds(tid);
+        throttle(this.batchInvoke, uploadInterval, false, false)(tid);
+      }
+      // 发起visit请求时把存储里的originalSource删掉
+      const hasVisit = queues.some((e) => e.eventType === 'VISIT');
+      if (hasVisit) {
+        minipInstance.removeStorageSync(
+          dataStore.getStorageKey(tid, 'originalSource')
+        );
+      }
+    };
+    if (queues.length > 0) {
+      // 同时请求数在3个以下直接发起请求
+      if (this.requestingNum < this.requestLimit) {
+        requestProcess(trackingId);
       } else {
-        this.batchInvokeThrottle();
+        // 同时有3个请求在发送时，设轮询延时直到请求数在3个以下
+        let t = setInterval(() => {
+          if (this.requestingNum < this.requestLimit) {
+            requestProcess(trackingId);
+            clearInterval(t);
+            t = undefined;
+          }
+        }, 500);
       }
     }
   };
 
   // 批量发送无延时(强制发送)
-  batchInvoke = () => {
-    const { vdsConfig, plugins, emitter } = this.growingIO;
-    let queues = [...this.hoardingQueue, ...this.requestQueue];
+  batchInvoke = (trackingId: string) => {
+    const { vdsConfig, emitter } = this.growingIO;
+    const hoardingQueue = this.getHoardingQueue(trackingId);
+    const requestQueue = this.getRequestQueue(trackingId);
+    let queues = [...hoardingQueue, ...requestQueue];
     // 如果事件数大于50，剩下的切断放到下次请求
     if (queues.length > 50) {
       queues = queues.slice(0, 50);
       // 如果积压队列超过50，只截取积压队列，剩下的下一次发
-      if (this.hoardingQueue.length > 50) {
-        this.hoardingQueue = this.hoardingQueue.slice(50);
+      if (hoardingQueue.length > 50) {
+        this.hoardingQueue[trackingId] = hoardingQueue.slice(50);
       } else {
         // 如果积压队列小于50，正常的请求队列就只截取补满50后剩下的事件
-        this.hoardingQueue = [];
-        this.requestQueue = this.requestQueue.slice(
-          50 - this.hoardingQueue.length
+        this.requestQueue[trackingId] = requestQueue.slice(
+          50 - hoardingQueue.length
         );
+        this.hoardingQueue[trackingId] = [];
       }
     } else {
-      this.hoardingQueue = [];
-      this.requestQueue = [];
+      this.hoardingQueue[trackingId] = [];
+      this.requestQueue[trackingId] = [];
     }
     // 过滤掉重试超过3次的请求(直接丢弃)
-    let eventsQueue: Event[] = queues.filter(
+    let eventsQueue: EXTEND_EVENT[] = queues.filter(
       (o) => (this.retryIds[o.requestId] || 0) <= this.retryLimit
     );
     if (isEmpty(eventsQueue)) {
       return;
     }
     // 生成新的请求事件（过滤事件中不能被上报的字段）
-    const requestData = eventsQueue.map((eData) => {
+    const requestData: EVENT[] = eventsQueue.map((eData) => {
       const rdata = { ...eData };
-      unset(rdata, 'requestId');
+      unset(rdata, ['requestId', 'trackingId']);
       return rdata;
     });
     // 开启debug模式时，打印事件日志
@@ -122,25 +179,18 @@ class Uploader implements UploaderType {
       console.log('[GrowingIO Debug]:', JSON.stringify(requestData, null, 2));
     }
     // 广播事件
-    emitter.emit('onSendBefore', { requestData });
-    if (vdsConfig?.tbConfig?.cloudAppId) {
-      plugins?.gioTaobaoAdapter?.tbCloudAppInvoke(requestData);
-    } else {
-      this.normalBatchInvoke(eventsQueue, requestData);
-    }
+    emitter.emit(EMIT_MSG.ON_SEND_BEFORE, {
+      eventsQueue,
+      requestData,
+      trackingId
+    });
   };
 
-  // 批量发送(1秒钟之内产生的请求只会组团发送一次)
-  batchInvokeThrottle = throttle(
-    this.batchInvoke,
-    this.growingIO.vdsConfig.uploadInterval,
-    false,
-    false
-  );
-
-  // 基础请求逻辑
-  normalBatchInvoke = (eventsQueue: any, requestData: any) => {
-    const { minipInstance, vdsConfig, emitter, plugins } = this.growingIO;
+  // 发送事件
+  sendEvent = (eventsQueue: EXTEND_EVENT[], requestData: EVENT[]) => {
+    const trackingId = head(eventsQueue).trackingId;
+    const { minipInstance, dataStore, emitter, plugins } = this.growingIO;
+    const { compress, requestTimeout } = dataStore.getTrackerVds(trackingId);
     this.requestingNum += 1;
     // 根据设置拼装最后请求数据
     const header: any = {
@@ -153,61 +203,55 @@ class Uploader implements UploaderType {
     };
     let compressData = [...requestData];
     // 数据加密
-    const isCompress =
-      vdsConfig.compress && plugins?.gioCompress?.compressToUTF16;
+    const isCompress = !!compress && plugins?.gioCompress?.compressToUTF16;
     if (isCompress) {
       compressData = plugins.gioCompress.compressToUTF16(
         JSON.stringify(requestData)
       );
       header['X-Compress-Codec'] = '1';
     }
+    const sendURL = this.generateURL(trackingId);
     minipInstance.request({
-      url: `${this.requestURL}?stm=${Date.now()}&compress=${
-        isCompress ? '1' : '0'
-      }`,
+      url: `${sendURL}?stm=${Date.now()}&compress=${isCompress ? '1' : '0'}`,
       header,
       method: 'POST',
       data: compressData,
-      timeout: this.requestTimeout,
+      timeout: requestTimeout,
       fail: (result: any) => {
         if (![200, 204].includes(result.code)) {
-          if (isArray(eventsQueue)) {
-            eventsQueue.forEach((o: any) => {
-              this.requestFailFn(o);
-            });
-          } else {
-            this.requestFailFn(eventsQueue);
-          }
+          eventsQueue.forEach((o: any) => {
+            this.requestFailFn(o);
+          });
           consoleText(`请求失败!${JSON.stringify(result)}`, 'error');
         }
       },
       complete: (args: any) => {
         this.requestingNum -= 1;
-        emitter.emit('onSendAfter', { result: args });
-        this.initiateRequest();
+        emitter.emit(EMIT_MSG.ON_SEND_AFTER, { result: args, requestData });
+        this.initiateRequest(trackingId);
       }
     });
   };
 
   // 请求失败的回调
-  requestFailFn = (eventsQueue: any) => {
+  requestFailFn = (event: EXTEND_EVENT) => {
     // 把重试的请求进行计数，超过重试上限的会被丢弃
-    if (!this.retryIds[eventsQueue.requestId]) {
-      this.retryIds[eventsQueue.requestId] = 0;
+    if (!this.retryIds[event.requestId]) {
+      this.retryIds[event.requestId] = 0;
     }
-    this.retryIds[eventsQueue.requestId] += 1;
+    this.retryIds[event.requestId] += 1;
     // 发送失败的事件会重新推入请求队列
-    const eventExist = this.requestQueue.some(
-      (o) => o.requestId === eventsQueue.requestId
+    const eventExist = this.requestQueue[event.trackingId].some(
+      (o) => o.requestId === event.requestId
     );
     if (!eventExist) {
       // 延迟半秒后再推入请求队列，给网络一点恢复时间
       let t = setTimeout(() => {
-        if (!isEmpty(this.requestQueue)) {
-          this.requestQueue.push(eventsQueue);
+        if (!isEmpty(this.requestQueue[event.trackingId])) {
+          this.requestQueue[event.trackingId].push(event);
         } else {
-          this.requestQueue.push(eventsQueue);
-          this.initiateRequest();
+          this.requestQueue[event.trackingId].push(event);
+          this.initiateRequest(event.trackingId);
         }
         clearTimeout(t);
         t = null;