@pluve/logger-sdk 0.0.7 → 0.0.9

package/dist/esm/core/queueManager.js

@@ -0,0 +1,269 @@
+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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+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 __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/core/queueManager.ts
+import { isBrowser, isWeChatMiniProgram } from "../utils/environment";
+import { logDebug, safeStringify } from "../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();
+      }
+    });
+  }
+  loadLocalForage() {
+    return __async(this, null, function* () {
+      try {
+        if (isBrowser()) {
+          Promise.resolve().then(() => __toESM(__require("localforage"))).then((res) => {
+            this.localforage = res;
+            logDebug(!!this.opts.debug, res);
+          });
+        }
+      } catch (e) {
+        logDebug(!!this.opts.debug, "localforage load error", e);
+      }
+      return null;
+    });
+  }
+  /**
+   * 添加日志到队列
+   */
+  enqueue(event) {
+    if (this.queue.length >= this.opts.maxSize) {
+      this.queue.shift();
+      logDebug(!!this.opts.debug, "Queue full, dropped oldest event");
+    }
+    this.queue.push(event);
+    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);
+    logDebug(!!this.opts.debug, `Dequeued ${items.length} events`);
+    if (this.opts.enableStorage) {
+      this.saveToStorage();
+    }
+    return items;
+  }
+  /**
+   * 获取队列长度
+   */
+  size() {
+    return this.queue.length;
+  }
+  /**
+   * 清空队列
+   */
+  clear() {
+    this.queue = [];
+    logDebug(!!this.opts.debug, "Queue cleared");
+    if (this.opts.enableStorage) {
+      this.removeFromStorage();
+    }
+  }
+  /**
+   * 从持久化存储加载队列
+   */
+  loadFromStorage() {
+    return __async(this, null, function* () {
+      try {
+        let stored = null;
+        if (isWeChatMiniProgram()) {
+          stored = wx.getStorageSync(this.storageKey);
+        } else if (isBrowser()) {
+          if (!this.localforage) {
+            yield this.loadLocalForage();
+          }
+          try {
+            const items = this.localforage ? yield this.localforage.getItem(this.storageKey) : null;
+            if (Array.isArray(items)) {
+              this.queue = items.slice(0, this.opts.maxSize);
+              logDebug(!!this.opts.debug, `Loaded ${this.queue.length} events from IndexedDB`);
+              return;
+            }
+          } catch (err) {
+            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);
+                  logDebug(!!this.opts.debug, `Loaded ${this.queue.length} events from localStorage`);
+                }
+              } catch (e) {
+              }
+            }
+          }
+          return;
+        }
+        if (stored) {
+          const parsed = JSON.parse(stored);
+          if (Array.isArray(parsed)) {
+            this.queue = parsed.slice(0, this.opts.maxSize);
+            logDebug(!!this.opts.debug, `Loaded ${this.queue.length} events from storage`);
+          }
+        }
+      } catch (error) {
+        logDebug(!!this.opts.debug, "Failed to load queue from storage", error);
+      }
+    });
+  }
+  /**
+   * 保存队列到持久化存储
+   */
+  saveToStorage() {
+    try {
+      const data = safeStringify(this.queue);
+      if (isWeChatMiniProgram()) {
+        wx.setStorageSync(this.storageKey, data);
+      } else if (isBrowser()) {
+        const saveToLocalStorage = () => {
+          if (typeof localStorage !== "undefined") {
+            localStorage.setItem(this.storageKey, data);
+            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(() => {
+                logDebug(!!this.opts.debug, `Saved ${this.queue.length} events to IndexedDB`);
+              }).catch((err) => {
+                logDebug(!!this.opts.debug, "IndexedDB save error, falling back to localStorage", err);
+                saveToLocalStorage();
+              });
+            }
+            saveToLocalStorage();
+            return null;
+          }).catch((err) => {
+            logDebug(!!this.opts.debug, "IndexedDB save error, falling back to localStorage", err);
+            saveToLocalStorage();
+          });
+        } else {
+          this.localforage.setItem(this.storageKey, this.queue).then(() => {
+            logDebug(!!this.opts.debug, `Saved ${this.queue.length} events to IndexedDB`);
+          }).catch((err) => {
+            logDebug(!!this.opts.debug, "IndexedDB save error, falling back to localStorage", err);
+            saveToLocalStorage();
+          });
+        }
+      }
+    } catch (error) {
+      logDebug(!!this.opts.debug, "Failed to save queue to storage", error);
+    }
+  }
+  /**
+   * 从持久化存储移除队列
+   */
+  removeFromStorage() {
+    try {
+      if (isWeChatMiniProgram()) {
+        wx.removeStorageSync(this.storageKey);
+      } else if (isBrowser()) {
+        const removeFromLocalStorage = () => {
+          if (typeof localStorage !== "undefined") {
+            localStorage.removeItem(this.storageKey);
+            logDebug(!!this.opts.debug, "Removed queue from localStorage");
+          }
+        };
+        if (!this.localforage) {
+          this.loadLocalForage().then(() => {
+            if (this.localforage) {
+              return this.localforage.removeItem(this.storageKey).then(() => {
+                logDebug(!!this.opts.debug, "Removed queue from IndexedDB");
+              }).catch((err) => {
+                logDebug(!!this.opts.debug, "IndexedDB remove error, falling back to localStorage", err);
+                removeFromLocalStorage();
+              });
+            }
+            removeFromLocalStorage();
+            return null;
+          }).catch((err) => {
+            logDebug(!!this.opts.debug, "IndexedDB remove error, falling back to localStorage", err);
+            removeFromLocalStorage();
+          });
+        } else {
+          this.localforage.removeItem(this.storageKey).then(() => {
+            logDebug(!!this.opts.debug, "Removed queue from IndexedDB");
+          }).catch((err) => {
+            logDebug(!!this.opts.debug, "IndexedDB remove error, falling back to localStorage", err);
+            removeFromLocalStorage();
+          });
+        }
+      }
+    } catch (error) {
+      logDebug(!!this.opts.debug, "Failed to remove queue from storage", error);
+    }
+  }
+};
+export {
+  QueueManager
+};

package/dist/esm/core/retryManager.js

@@ -0,0 +1,129 @@
+var __pow = Math.pow;
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/core/retryManager.ts
+import { logDebug } from "../utils/tools";
+var RetryManager = class {
+  constructor(options) {
+    this.retryingTasks = /* @__PURE__ */ new Map();
+    this.opts = options;
+  }
+  /**
+   * 执行带重试的任务
+   * @param taskId - 任务唯一标识
+   * @param fn - 要执行的异步函数
+   * @returns Promise
+   */
+  executeWithRetry(taskId, fn) {
+    return __async(this, null, function* () {
+      if (this.retryingTasks.has(taskId)) {
+        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 = yield this.executeTask(task);
+        this.retryingTasks.delete(taskId);
+        return result;
+      } catch (error) {
+        this.retryingTasks.delete(taskId);
+        throw error;
+      }
+    });
+  }
+  /**
+   * 执行任务（带重试逻辑）
+   */
+  executeTask(task) {
+    return __async(this, null, function* () {
+      while (task.retries <= task.maxRetries) {
+        try {
+          const result = yield task.fn();
+          if (task.retries > 0) {
+            logDebug(!!this.opts.debug, `Task ${task.id} succeeded after ${task.retries} retries`);
+          }
+          return result;
+        } catch (error) {
+          task.retries += 1;
+          if (task.retries > task.maxRetries) {
+            logDebug(!!this.opts.debug, `Task ${task.id} failed after ${task.maxRetries} retries`);
+            throw error;
+          }
+          const delay = RetryManager.calculateDelay(task.retries, task.baseDelay, task.useBackoff);
+          logDebug(
+            !!this.opts.debug,
+            `Task ${task.id} failed (attempt ${task.retries}/${task.maxRetries}), retrying in ${delay}ms`
+          );
+          yield 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 = __pow(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();
+  }
+};
+export {
+  RetryManager
+};

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+// src/index.ts
+import { LoggerSDK } from "./core/loggerSDK";
+export {
+  LoggerSDK
+};

package/dist/esm/stack/stacktrace.js

@@ -0,0 +1,37 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/stack/stacktrace.ts
+import StackTrace from "stacktrace-js";
+function parseStack(error) {
+  return __async(this, null, function* () {
+    const frames = yield StackTrace.fromError(error);
+    return frames.slice(0, 5).map((f) => ({
+      file: f.fileName || "",
+      line: f.lineNumber || 0,
+      column: f.columnNumber || 0,
+      function: f.functionName || void 0
+    }));
+  });
+}
+export {
+  parseStack
+};

package/dist/esm/transport/beaconTransport.js

@@ -0,0 +1,81 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/transport/beaconTransport.ts
+import { gzipCompress } from "../compress/compression";
+import { getReportApi } from "../config";
+import { isBrowser } from "../utils/environment";
+import { logDebug, safeStringify } from "../utils/tools";
+var BeaconTransport = class {
+  constructor(opts) {
+    /** 传输器名称 */
+    this.name = "beacon";
+    this.opts = opts;
+  }
+  // eslint-disable-next-line class-methods-use-this
+  isSupported() {
+    return isBrowser() && typeof navigator !== "undefined" && navigator.sendBeacon && typeof navigator.sendBeacon === "function";
+  }
+  send(payload) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d, _e;
+      let body = typeof payload === "string" ? payload : safeStringify(payload);
+      const endpoint = getReportApi(((_a = this.opts) == null ? void 0 : _a.env) || "develop");
+      let contentType = "application/json";
+      if (((_b = this.opts) == null ? void 0 : _b.enableGzip) && (!((_c = this.opts) == null ? void 0 : _c.gzipOnlyInBatchMode) || payload.items.length > 0)) {
+        const compressedItems = yield gzipCompress(safeStringify(payload.items));
+        body = safeStringify(__spreadProps(__spreadValues({}, payload), {
+          items: compressedItems
+        }));
+        contentType = "application/json; charset=utf-8";
+      }
+      const blob = new Blob([body], { type: contentType });
+      const success = navigator.sendBeacon(endpoint, blob);
+      logDebug(!!((_d = this.opts) == null ? void 0 : _d.debug), "sendBeacon result", success);
+      if (!success) {
+        logDebug(!!((_e = this.opts) == null ? void 0 : _e.debug), "sendBeacon failed (queue full or other error)");
+      }
+      return Promise.resolve();
+    });
+  }
+};
+export {
+  BeaconTransport
+};

package/dist/esm/transport/pixelImageTransport.js

@@ -0,0 +1,99 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/transport/pixelImageTransport.ts
+import { Base64 } from "js-base64";
+import { isBrowser } from "../utils/environment";
+import { logDebug, now, safeStringify } from "../utils/tools";
+import { getPixelBatchApi } from "../config";
+import { gzipCompress } from "../compress/compression";
+var PixelImageTransport = class {
+  constructor(opts) {
+    /** 传输器名称 */
+    this.name = "image";
+    this.opts = opts;
+  }
+  // eslint-disable-next-line class-methods-use-this
+  isSupported() {
+    return isBrowser() && typeof Image !== "undefined";
+  }
+  send(payload) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+      const body = safeStringify(payload.items);
+      const endpoint = getPixelBatchApi(((_a = this.opts) == null ? void 0 : _a.env) || "develop");
+      const param = "items";
+      const maxLen = ((_b = this.opts) == null ? void 0 : _b.maxPixelUrlLen) || 8192;
+      let compressedBody;
+      if (((_c = this.opts) == null ? void 0 : _c.enableGzip) && (!((_d = this.opts) == null ? void 0 : _d.gzipOnlyInBatchMode) || payload.items.length > 0)) {
+        const t = now();
+        logDebug(!!((_e = this.opts) == null ? void 0 : _e.debug), "PixelImage request gzip compress body: ", body);
+        compressedBody = yield gzipCompress(body);
+        logDebug(!!((_f = this.opts) == null ? void 0 : _f.debug), "PixelImage request gzip compress cost: ", now() - t);
+        logDebug(!!((_g = this.opts) == null ? void 0 : _g.debug), `original body size: ${body.length}, compressed body size: ${compressedBody.length}`);
+        logDebug(!!((_h = this.opts) == null ? void 0 : _h.debug), "PixelImage request gzip compress body: ", compressedBody);
+      } else {
+        compressedBody = Base64.encode(body, false);
+      }
+      const cacheBuster = `_=${Date.now()}`;
+      const qs = `appId=${((_i = this.opts) == null ? void 0 : _i.appId) || ""}&appStage=${((_j = this.opts) == null ? void 0 : _j.logStage) || ""}&${param}=${encodeURIComponent(compressedBody)}&gzip=${((_k = this.opts) == null ? void 0 : _k.enableGzip) ? 1 : 0}&${cacheBuster}`;
+      const url = endpoint.includes("?") ? `${endpoint}&${qs}` : `${endpoint}?${qs}`;
+      if (url.length > maxLen) {
+        logDebug(!!((_l = this.opts) == null ? void 0 : _l.debug), `URL too long (${url.length} > ${maxLen})`);
+      }
+      return new Promise((resolve, reject) => {
+        const img = new Image();
+        let timeoutId = null;
+        let settled = false;
+        timeoutId = setTimeout(() => {
+          if (!settled) {
+            settled = true;
+            img.src = "";
+            reject(new Error("Image request timeout after 5000ms"));
+          }
+        }, 5e3);
+        img.onload = () => {
+          if (timeoutId)
+            clearTimeout(timeoutId);
+          if (!settled) {
+            settled = true;
+            resolve();
+          }
+        };
+        img.onerror = (event, source, lineno, colno, error) => {
+          var _a2, _b2;
+          logDebug(!!((_a2 = this.opts) == null ? void 0 : _a2.debug), "Image request failed", event, source, lineno, colno, error);
+          if (timeoutId)
+            clearTimeout(timeoutId);
+          if (!settled) {
+            settled = true;
+            logDebug(!!((_b2 = this.opts) == null ? void 0 : _b2.debug), "Image request failed", event, source, lineno, colno, error);
+            resolve();
+          }
+        };
+        img.src = url;
+      });
+    });
+  }
+};
+export {
+  PixelImageTransport
+};

package/dist/esm/transport/transportAdapter.js

@@ -0,0 +1,32 @@
+// src/transport/transportAdapter.ts
+import { isWeChatMiniProgram } from "../utils/environment";
+import { BeaconTransport } from "./beaconTransport";
+import { PixelImageTransport } from "./pixelImageTransport";
+import { WechatTransport } from "./wechatTransport";
+var TransportAdapter = class {
+  constructor(opts) {
+    this.beaconTransport = new BeaconTransport(opts);
+    this.pixelImageTransport = new PixelImageTransport(opts);
+    this.wechatTransport = new WechatTransport(opts);
+  }
+  static getInstance(opts) {
+    if (!TransportAdapter.instance) {
+      TransportAdapter.instance = new TransportAdapter(opts);
+    }
+    return TransportAdapter.instance;
+  }
+  getTransporter() {
+    if (isWeChatMiniProgram()) {
+      return this.wechatTransport;
+    }
+    const transports = [this.beaconTransport, this.pixelImageTransport];
+    const transporter = transports.find((t) => t.isSupported());
+    if (!transporter) {
+      return this.pixelImageTransport;
+    }
+    return transporter;
+  }
+};
+export {
+  TransportAdapter
+};