@pluve/logger-sdk 0.0.7 → 0.0.8

package/dist/cjs/core/queueManager.js

@@ -0,0 +1,249 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/queueManager.ts
+var queueManager_exports = {};
+__export(queueManager_exports, {
+  QueueManager: () => QueueManager
+});
+module.exports = __toCommonJS(queueManager_exports);
+var import_environment = require("../utils/environment");
+var import_tools = require("../utils/tools");
+var QueueManager = class {
+  constructor(options) {
+    this.queue = [];
+    this.localforage = null;
+    this.opts = options;
+    this.storageKey = `${options.storagePrefix}_queue`;
+    this.loadLocalForage().then(() => {
+      if (this.opts.enableStorage) {
+        this.loadFromStorage();
+      }
+    });
+  }
+  async loadLocalForage() {
+    try {
+      if ((0, import_environment.isBrowser)()) {
+        import("localforage").then((res) => {
+          this.localforage = res;
+          (0, import_tools.logDebug)(!!this.opts.debug, res);
+        });
+      }
+    } catch (e) {
+      (0, import_tools.logDebug)(!!this.opts.debug, "localforage load error", e);
+    }
+    return null;
+  }
+  /**
+   * 添加日志到队列
+   */
+  enqueue(event) {
+    if (this.queue.length >= this.opts.maxSize) {
+      this.queue.shift();
+      (0, import_tools.logDebug)(!!this.opts.debug, "Queue full, dropped oldest event");
+    }
+    this.queue.push(event);
+    (0, import_tools.logDebug)(!!this.opts.debug, "Enqueued event", event);
+    if (this.opts.enableStorage) {
+      this.saveToStorage();
+    }
+    return true;
+  }
+  /**
+   * 批量获取日志（不移除）
+   */
+  peek(count) {
+    return this.queue.slice(0, count);
+  }
+  /**
+   * 批量移除日志
+   */
+  dequeue(count) {
+    const items = this.queue.splice(0, count);
+    (0, import_tools.logDebug)(!!this.opts.debug, `Dequeued ${items.length} events`);
+    if (this.opts.enableStorage) {
+      this.saveToStorage();
+    }
+    return items;
+  }
+  /**
+   * 获取队列长度
+   */
+  size() {
+    return this.queue.length;
+  }
+  /**
+   * 清空队列
+   */
+  clear() {
+    this.queue = [];
+    (0, import_tools.logDebug)(!!this.opts.debug, "Queue cleared");
+    if (this.opts.enableStorage) {
+      this.removeFromStorage();
+    }
+  }
+  /**
+   * 从持久化存储加载队列
+   */
+  async loadFromStorage() {
+    try {
+      let stored = null;
+      if ((0, import_environment.isWeChatMiniProgram)()) {
+        stored = wx.getStorageSync(this.storageKey);
+      } else if ((0, import_environment.isBrowser)()) {
+        if (!this.localforage) {
+          await this.loadLocalForage();
+        }
+        try {
+          const items = this.localforage ? await this.localforage.getItem(this.storageKey) : null;
+          if (Array.isArray(items)) {
+            this.queue = items.slice(0, this.opts.maxSize);
+            (0, import_tools.logDebug)(!!this.opts.debug, `Loaded ${this.queue.length} events from IndexedDB`);
+            return;
+          }
+        } catch (err) {
+          (0, import_tools.logDebug)(!!this.opts.debug, "IndexedDB load error, falling back to localStorage", err);
+        }
+        if (typeof localStorage !== "undefined") {
+          const ls = localStorage.getItem(this.storageKey);
+          if (ls) {
+            try {
+              const parsed = JSON.parse(ls);
+              if (Array.isArray(parsed)) {
+                this.queue = parsed.slice(0, this.opts.maxSize);
+                (0, import_tools.logDebug)(!!this.opts.debug, `Loaded ${this.queue.length} events from localStorage`);
+              }
+            } catch {
+            }
+          }
+        }
+        return;
+      }
+      if (stored) {
+        const parsed = JSON.parse(stored);
+        if (Array.isArray(parsed)) {
+          this.queue = parsed.slice(0, this.opts.maxSize);
+          (0, import_tools.logDebug)(!!this.opts.debug, `Loaded ${this.queue.length} events from storage`);
+        }
+      }
+    } catch (error) {
+      (0, import_tools.logDebug)(!!this.opts.debug, "Failed to load queue from storage", error);
+    }
+  }
+  /**
+   * 保存队列到持久化存储
+   */
+  saveToStorage() {
+    try {
+      const data = (0, import_tools.safeStringify)(this.queue);
+      if ((0, import_environment.isWeChatMiniProgram)()) {
+        wx.setStorageSync(this.storageKey, data);
+      } else if ((0, import_environment.isBrowser)()) {
+        const saveToLocalStorage = () => {
+          if (typeof localStorage !== "undefined") {
+            localStorage.setItem(this.storageKey, data);
+            (0, import_tools.logDebug)(!!this.opts.debug, `Saved ${this.queue.length} events to localStorage`);
+          }
+        };
+        if (!this.localforage) {
+          this.loadLocalForage().then(() => {
+            if (this.localforage) {
+              return this.localforage.setItem(this.storageKey, this.queue).then(() => {
+                (0, import_tools.logDebug)(!!this.opts.debug, `Saved ${this.queue.length} events to IndexedDB`);
+              }).catch((err) => {
+                (0, import_tools.logDebug)(!!this.opts.debug, "IndexedDB save error, falling back to localStorage", err);
+                saveToLocalStorage();
+              });
+            }
+            saveToLocalStorage();
+            return null;
+          }).catch((err) => {
+            (0, import_tools.logDebug)(!!this.opts.debug, "IndexedDB save error, falling back to localStorage", err);
+            saveToLocalStorage();
+          });
+        } else {
+          this.localforage.setItem(this.storageKey, this.queue).then(() => {
+            (0, import_tools.logDebug)(!!this.opts.debug, `Saved ${this.queue.length} events to IndexedDB`);
+          }).catch((err) => {
+            (0, import_tools.logDebug)(!!this.opts.debug, "IndexedDB save error, falling back to localStorage", err);
+            saveToLocalStorage();
+          });
+        }
+      }
+    } catch (error) {
+      (0, import_tools.logDebug)(!!this.opts.debug, "Failed to save queue to storage", error);
+    }
+  }
+  /**
+   * 从持久化存储移除队列
+   */
+  removeFromStorage() {
+    try {
+      if ((0, import_environment.isWeChatMiniProgram)()) {
+        wx.removeStorageSync(this.storageKey);
+      } else if ((0, import_environment.isBrowser)()) {
+        const removeFromLocalStorage = () => {
+          if (typeof localStorage !== "undefined") {
+            localStorage.removeItem(this.storageKey);
+            (0, import_tools.logDebug)(!!this.opts.debug, "Removed queue from localStorage");
+          }
+        };
+        if (!this.localforage) {
+          this.loadLocalForage().then(() => {
+            if (this.localforage) {
+              return this.localforage.removeItem(this.storageKey).then(() => {
+                (0, import_tools.logDebug)(!!this.opts.debug, "Removed queue from IndexedDB");
+              }).catch((err) => {
+                (0, import_tools.logDebug)(!!this.opts.debug, "IndexedDB remove error, falling back to localStorage", err);
+                removeFromLocalStorage();
+              });
+            }
+            removeFromLocalStorage();
+            return null;
+          }).catch((err) => {
+            (0, import_tools.logDebug)(!!this.opts.debug, "IndexedDB remove error, falling back to localStorage", err);
+            removeFromLocalStorage();
+          });
+        } else {
+          this.localforage.removeItem(this.storageKey).then(() => {
+            (0, import_tools.logDebug)(!!this.opts.debug, "Removed queue from IndexedDB");
+          }).catch((err) => {
+            (0, import_tools.logDebug)(!!this.opts.debug, "IndexedDB remove error, falling back to localStorage", err);
+            removeFromLocalStorage();
+          });
+        }
+      }
+    } catch (error) {
+      (0, import_tools.logDebug)(!!this.opts.debug, "Failed to remove queue from storage", error);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  QueueManager
+});

package/dist/cjs/core/retryManager.js

@@ -0,0 +1,127 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/retryManager.ts
+var retryManager_exports = {};
+__export(retryManager_exports, {
+  RetryManager: () => RetryManager
+});
+module.exports = __toCommonJS(retryManager_exports);
+var import_tools = require("../utils/tools");
+var RetryManager = class {
+  constructor(options) {
+    this.retryingTasks = /* @__PURE__ */ new Map();
+    this.opts = options;
+  }
+  /**
+   * 执行带重试的任务
+   * @param taskId - 任务唯一标识
+   * @param fn - 要执行的异步函数
+   * @returns Promise
+   */
+  async executeWithRetry(taskId, fn) {
+    if (this.retryingTasks.has(taskId)) {
+      (0, import_tools.logDebug)(!!this.opts.debug, `Task ${taskId} already retrying, skipped`);
+      throw new Error(`Task ${taskId} already retrying`);
+    }
+    const task = {
+      id: taskId,
+      fn,
+      retries: 0,
+      maxRetries: this.opts.maxRetries,
+      baseDelay: this.opts.baseDelay,
+      useBackoff: this.opts.useBackoff
+    };
+    this.retryingTasks.set(taskId, task);
+    try {
+      const result = await this.executeTask(task);
+      this.retryingTasks.delete(taskId);
+      return result;
+    } catch (error) {
+      this.retryingTasks.delete(taskId);
+      throw error;
+    }
+  }
+  /**
+   * 执行任务（带重试逻辑）
+   */
+  async executeTask(task) {
+    while (task.retries <= task.maxRetries) {
+      try {
+        const result = await task.fn();
+        if (task.retries > 0) {
+          (0, import_tools.logDebug)(!!this.opts.debug, `Task ${task.id} succeeded after ${task.retries} retries`);
+        }
+        return result;
+      } catch (error) {
+        task.retries += 1;
+        if (task.retries > task.maxRetries) {
+          (0, import_tools.logDebug)(!!this.opts.debug, `Task ${task.id} failed after ${task.maxRetries} retries`);
+          throw error;
+        }
+        const delay = RetryManager.calculateDelay(task.retries, task.baseDelay, task.useBackoff);
+        (0, import_tools.logDebug)(
+          !!this.opts.debug,
+          `Task ${task.id} failed (attempt ${task.retries}/${task.maxRetries}), retrying in ${delay}ms`
+        );
+        await RetryManager.sleep(delay);
+      }
+    }
+    throw new Error(`Task ${task.id} exceeded max retries`);
+  }
+  /**
+   * 计算延迟时间
+   * @param attempt - 当前重试次数
+   * @param baseDelay - 基础延迟时间
+   * @param useBackoff - 是否使用指数退避
+   * @returns 延迟时间（毫秒）
+   */
+  static calculateDelay(attempt, baseDelay, useBackoff) {
+    if (!useBackoff) {
+      return baseDelay;
+    }
+    const factor = 2 ** (attempt - 1);
+    const delay = baseDelay * factor;
+    const jitterRatio = 0.3;
+    const maxDelay = 3e4;
+    const jitter = Math.random() * jitterRatio * delay;
+    return Math.min(delay + jitter, maxDelay);
+  }
+  /**
+   * 睡眠函数
+   */
+  static sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * 获取正在重试的任务数量
+   */
+  getRetryingCount() {
+    return this.retryingTasks.size;
+  }
+  /**
+   * 清空所有重试任务
+   */
+  clear() {
+    this.retryingTasks.clear();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RetryManager
+});

package/dist/cjs/index.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  LoggerSDK: () => import_loggerSDK.LoggerSDK
+});
+module.exports = __toCommonJS(src_exports);
+var import_loggerSDK = require("./core/loggerSDK");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LoggerSDK
+});

package/dist/cjs/logger-sdk.mermaid

@@ -0,0 +1,84 @@
+flowchart TD
+  A[初始化 SDK] --> B[设置选项（批量/重试/gzip/自动采集）]
+  B --> C{启用批量?}
+  C -->|是| D[创建队列管理器并加载存储]
+  C -->|否| E[跳过队列管理器]
+  B --> F{启用重试?}
+  F -->|是| G[创建重试管理器]
+  F -->|否| H[跳过重试管理器]
+  B --> I[选择传输适配器]
+  I --> J{运行环境}
+  J -->|微信小程序| K[WechatTransport]
+  J -->|浏览器| L{支持 Beacon?}
+  L -->|是| M[BeaconTransport]
+  L -->|否| N[PixelImageTransport]
+  B --> O[生成会话ID]
+  B --> P[收集环境标签]
+  B --> Q[注册 SDK]
+  Q --> R[接收初始化数据: 开关/等级/采样率]
+  R --> S{启用批量?}
+  S -->|是| T[启动批量定时器]
+  R --> U[挂载卸载/可见性事件处理]
+  U --> V{enableAutoCapture?}
+  V -->|是| V1[按 autoCapture: 注册 js/promise/resource/wechat]
+  V -->|否| V2[跳过自动采集]
+
+  subgraph 采集与上报
+    W[调用 track 或自动采集] --> X{已初始化且未关闭?}
+    X -->|否| X1[跳过]
+    X -->|是| X2{3秒去重窗口?}
+    X2 -->|重复| X3[跳过]
+    X2 -->|非重复| Y{shouldSend 采样?}
+    Y -->|否| Y1[采样丢弃]
+    Y -->|是| Z[构建 LogEvent]
+    Z --> AA{启用批量?}
+    AA -->|是| AB[enqueue 入队]
+    AB --> AC{队列达到批量阈值?}
+    AC -->|是| AD[flush 刷新]
+    AC -->|否| AE[等待定时器/下一次触发]
+    AA -->|否| AF[sendEvent 直接发送]
+  end
+
+  subgraph 批量刷新
+    AD --> AG[peek 读取待发事件]
+    AG --> AH[sendBatch 批量发送]
+    AH --> AI[按 appId & stage 分组并分块]
+    AI --> AJ[transporter.send（并发收集）]
+    AJ --> AK[dequeue 成功后出队]
+  end
+
+  subgraph 传输细节
+    K --> K1[字符串化; 启用 gzip 时压缩成 Base64; wx.request POST]
+    M --> M1{启用 gzip? 且满足批量条件}
+    M1 -->|是| M2[压缩 items 为 Base64 字符串; 替换 body 为 「...payload, items: Base64」; 设置 Content-Type]
+    M1 -->|否| M3[直接 JSON body; Blob 包裹; sendBeacon POST]
+    N --> N1[字符串化 items; gzip: Base64 / btoa / encodeURIComponent 回退; Image GET]
+  end
+
+  subgraph 压缩流程
+    C1[gzipCompress（data）] --> C2{支持 CompressionStream?}
+    C2 -->|是| C3[CompressionStream（'gzip'） 流式压缩后 Base64]
+    C2 -->|否| C4[fflate.gzipSync + Base64.fromUint8Array]
+  end
+
+  subgraph 定时与卸载
+    T --> T1[setInterval 周期性 flush]
+    U --> U1[visibilitychange/pagehide/beforeunload 触发 flush]
+    V1 --> U2[销毁时统一 off（js/promise/resource/wechat）]
+  end
+
+  subgraph 重试策略
+    AF --> R1{启用重试?}
+    R1 -->|是| R2[executeWithRetry（event.logId, sendFn）]
+    R1 -->|否| R3[直接 sendFn]
+    AH --> R4{启用重试?}
+    R4 -->|是| R5[executeWithRetry（batchId, sendFn）]
+    R4 -->|否| R6[直接 sendFn]
+  end
+
+  subgraph 存储兼容
+    D --> D1{环境}
+    D1 -->|浏览器| D2[动态 import localforage 使用 IndexedDB; 失败回退 localStorage]
+    D2 --> D2a[如解析失败: 回退 globalThis.localforage]
+    D1 -->|微信小程序| D3[使用 wx.storage 同步 API]
+  end