@pluve/logger-sdk 0.0.6 → 0.0.8

package/dist/cjs/capture/jsError.js

@@ -0,0 +1,48 @@
+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/capture/jsError.ts
+var jsError_exports = {};
+__export(jsError_exports, {
+  registerJsErrorCapture: () => registerJsErrorCapture
+});
+module.exports = __toCommonJS(jsError_exports);
+var import_stacktrace = require("../stack/stacktrace");
+var import_tools = require("../utils/tools");
+function registerJsErrorCapture(debug, callback) {
+  if (typeof window === "undefined")
+    return void 0;
+  const handler = async (e) => {
+    (0, import_tools.logDebug)(debug, "registerJsErrorCapture error", e);
+    if (!e.error)
+      return;
+    const stack = await (0, import_stacktrace.parseStack)(e.error);
+    callback({
+      type: "js",
+      message: e.error.message,
+      stack,
+      throwable: e.error.stack || ""
+    });
+  };
+  window.addEventListener("error", handler);
+  return () => window.removeEventListener("error", handler);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerJsErrorCapture
+});

package/dist/cjs/capture/promiseError.js

@@ -0,0 +1,49 @@
+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/capture/promiseError.ts
+var promiseError_exports = {};
+__export(promiseError_exports, {
+  registerPromiseErrorCapture: () => registerPromiseErrorCapture
+});
+module.exports = __toCommonJS(promiseError_exports);
+var import_stacktrace = require("../stack/stacktrace");
+var import_tools = require("../utils/tools");
+function registerPromiseErrorCapture(debug, callback) {
+  if (typeof window === "undefined")
+    return void 0;
+  const handler = async (e) => {
+    (0, import_tools.logDebug)(debug, "registerPromiseErrorCapture unhandledrejection", e);
+    const { reason } = e;
+    if (reason instanceof Error) {
+      const stack = await (0, import_stacktrace.parseStack)(reason);
+      callback({
+        type: "promise",
+        message: reason.message,
+        stack,
+        throwable: reason.stack || ""
+      });
+    }
+  };
+  window.addEventListener("unhandledrejection", handler);
+  return () => window.removeEventListener("unhandledrejection", handler);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerPromiseErrorCapture
+});

package/dist/cjs/capture/resourceError.js

@@ -0,0 +1,48 @@
+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/capture/resourceError.ts
+var resourceError_exports = {};
+__export(resourceError_exports, {
+  registerResourceErrorCapture: () => registerResourceErrorCapture
+});
+module.exports = __toCommonJS(resourceError_exports);
+var import_tools = require("../utils/tools");
+function registerResourceErrorCapture(debug, callback) {
+  if (typeof window === "undefined")
+    return void 0;
+  const handler = (e) => {
+    var _a;
+    (0, import_tools.logDebug)(debug, "registerResourceErrorCapture error", e);
+    const target = e.target;
+    if ((target == null ? void 0 : target.src) || (target == null ? void 0 : target.href)) {
+      callback({
+        type: "resource",
+        message: `Resource load failed: ${(target == null ? void 0 : target.src) || (target == null ? void 0 : target.href)}`,
+        stack: [],
+        throwable: ((_a = e == null ? void 0 : e.error) == null ? void 0 : _a.stack) || ""
+      });
+    }
+  };
+  window.addEventListener("error", handler, true);
+  return () => window.removeEventListener("error", handler, true);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerResourceErrorCapture
+});

package/dist/cjs/capture/wechatError.js

@@ -0,0 +1,95 @@
+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/capture/wechatError.ts
+var wechatError_exports = {};
+__export(wechatError_exports, {
+  registerWechatErrorCapture: () => registerWechatErrorCapture,
+  registerWechatUnhandledCapture: () => registerWechatUnhandledCapture
+});
+module.exports = __toCommonJS(wechatError_exports);
+var import_stacktrace = require("../stack/stacktrace");
+var import_environment = require("../utils/environment");
+var import_tools = require("../utils/tools");
+function registerWechatErrorCapture(debug, callback) {
+  if (!(0, import_environment.isWeChatMiniProgram)())
+    return void 0;
+  try {
+    const wxAny = globalThis.wx;
+    if (wxAny && typeof wxAny.onError === "function") {
+      const handler = async (error) => {
+        (0, import_tools.logDebug)(debug, "registerWechatErrorCapture onError", error);
+        const msg = String((error == null ? void 0 : error.message) ?? error);
+        const err = error instanceof Error ? error : new Error(msg);
+        const stack = await (0, import_stacktrace.parseStack)(err);
+        callback({
+          type: "js",
+          message: err.message,
+          stack,
+          throwable: err.stack || ""
+        });
+      };
+      wxAny.onError(handler);
+      return () => {
+        try {
+          wxAny.offError && wxAny.offError(handler);
+        } catch {
+        }
+      };
+    }
+  } catch (e) {
+    (0, import_tools.logDebug)(debug, "registerWechatErrorCapture attach failed", e);
+  }
+  return void 0;
+}
+function registerWechatUnhandledCapture(debug, callback) {
+  if (!(0, import_environment.isWeChatMiniProgram)())
+    return void 0;
+  try {
+    const wxAny = globalThis.wx;
+    if (wxAny && typeof wxAny.onUnhandledRejection === "function") {
+      const handler = async (res) => {
+        const reason = res == null ? void 0 : res.reason;
+        (0, import_tools.logDebug)(debug, "registerWechatUnhandledCapture onUnhandledRejection", reason);
+        const err = reason instanceof Error ? reason : new Error(String(reason));
+        const stack = await (0, import_stacktrace.parseStack)(err);
+        callback({
+          type: "promise",
+          message: err.message,
+          stack,
+          throwable: err.stack || ""
+        });
+      };
+      wxAny.onUnhandledRejection(handler);
+      return () => {
+        try {
+          wxAny.offUnhandledRejection && wxAny.offUnhandledRejection(handler);
+        } catch {
+        }
+      };
+    }
+  } catch (e) {
+    (0, import_tools.logDebug)(debug, "registerWechatUnhandledCapture attach failed", e);
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerWechatErrorCapture,
+  registerWechatUnhandledCapture
+});

package/dist/cjs/compress/compression.js

@@ -0,0 +1,84 @@
+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/compress/compression.ts
+var compression_exports = {};
+__export(compression_exports, {
+  gzipCompress: () => gzipCompress,
+  isGzipSupported: () => isGzipSupported
+});
+module.exports = __toCommonJS(compression_exports);
+var import_fflate = require("fflate");
+var import_js_base64 = require("js-base64");
+var import_environment = require("../utils/environment");
+function toUtf8Bytes(s) {
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(s);
+  }
+  const enc = encodeURIComponent(s);
+  const out = [];
+  for (let i = 0; i < enc.length; i += 1) {
+    const c = enc[i];
+    if (c === "%") {
+      out.push(parseInt(enc.slice(i + 1, i + 3), 16));
+      i += 2;
+    } else {
+      out.push(c.charCodeAt(0));
+    }
+  }
+  return new Uint8Array(out);
+}
+async function gzipCompress(data) {
+  if ((0, import_environment.isBrowser)() && typeof CompressionStream !== "undefined") {
+    try {
+      const encoder = new TextEncoder();
+      const input = encoder.encode(data);
+      const gzip = new CompressionStream("gzip");
+      const readable = new Blob([input]).stream();
+      const compressedStream = readable.pipeThrough(gzip);
+      const compressedBuffer = await new Response(compressedStream).arrayBuffer();
+      const bytes = new Uint8Array(compressedBuffer);
+      let binary = "";
+      for (let i = 0; i < bytes.byteLength; i += 1) {
+        binary += String.fromCharCode(bytes[i]);
+      }
+      if (typeof btoa !== "undefined") {
+        return btoa(binary);
+      }
+      return Buffer.from(binary, "base64").toString("base64");
+    } catch (e) {
+      console.log("gzipCompress 压缩失败，尝试使用 fflate 库", e);
+    }
+  }
+  try {
+    const input = toUtf8Bytes(data);
+    const compressed = (0, import_fflate.gzipSync)(input);
+    return import_js_base64.Base64.fromUint8Array(compressed, false);
+  } catch (e) {
+    console.log("gzipCompress 压缩失败", e);
+  }
+  return import_js_base64.Base64.encode(data, false);
+}
+function isGzipSupported() {
+  return (0, import_environment.isBrowser)() && typeof CompressionStream !== "undefined";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  gzipCompress,
+  isGzipSupported
+});

package/dist/cjs/config/index.js

@@ -0,0 +1,55 @@
+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/config/index.ts
+var config_exports = {};
+__export(config_exports, {
+  getPixelBatchApi: () => getPixelBatchApi,
+  getRegisterApi: () => getRegisterApi,
+  getReportApi: () => getReportApi,
+  getSDKBaseApi: () => getSDKBaseApi
+});
+module.exports = __toCommonJS(config_exports);
+var getSDKBaseApi = (env) => {
+  switch (env) {
+    case "product":
+      return "https://apm.pharmacyyf.com";
+    case "testing":
+      return "https://apm-te.pharmacyyf.com";
+    case "develop":
+      return "https://chief-dev.yifengx.com";
+    default:
+      return "https://apm.pharmacyyf.com";
+  }
+};
+var getRegisterApi = (env) => {
+  return `${getSDKBaseApi(env)}/yfcloud-apm/log/front/init`;
+};
+var getReportApi = (env) => {
+  return `${getSDKBaseApi(env)}/yfcloud-apm/log/front/batchSave`;
+};
+var getPixelBatchApi = (env) => {
+  return `${getSDKBaseApi(env)}/yfcloud-apm/log/front/pixelBatchSave`;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPixelBatchApi,
+  getRegisterApi,
+  getReportApi,
+  getSDKBaseApi
+});

package/dist/cjs/core/fingerprint.js

@@ -0,0 +1,36 @@
+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/fingerprint.ts
+var fingerprint_exports = {};
+__export(fingerprint_exports, {
+  generateFingerprint: () => generateFingerprint
+});
+module.exports = __toCommonJS(fingerprint_exports);
+var import_tools = require("../utils/tools");
+function generateFingerprint(error) {
+  var _a;
+  const msg = (0, import_tools.normalizeMessage)(error.message);
+  const frame = (_a = error.stack) == null ? void 0 : _a[0];
+  const frameKey = frame ? `${frame.file}:${frame.line}` : "no_frame";
+  return `${error.type}|${msg}|${frameKey}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateFingerprint
+});

package/dist/cjs/core/httpClient.js

@@ -0,0 +1,96 @@
+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/httpClient.ts
+var httpClient_exports = {};
+__export(httpClient_exports, {
+  HttpClient: () => HttpClient
+});
+module.exports = __toCommonJS(httpClient_exports);
+var import_environment = require("../utils/environment");
+var import_tools = require("../utils/tools");
+var HttpClient = class {
+  /**
+   * 发送 POST 请求,需要兼容浏览器和微信小程序
+   */
+  static async post(url, data, token) {
+    (0, import_tools.logDebug)(true, "post", url, data, token);
+    if ((0, import_environment.isWeChatMiniProgram)()) {
+      return new Promise((resolve, reject) => {
+        wx.request({
+          url,
+          method: "POST",
+          data: JSON.stringify(data),
+          header: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`
+          },
+          success: (res) => resolve({
+            type: "wechat",
+            response: res
+          }),
+          fail: (err) => (
+            // eslint-disable-next-line prefer-promise-reject-errors
+            reject({
+              type: "wechat",
+              error: err
+            })
+          )
+        });
+      });
+    }
+    if (typeof fetch === "undefined") {
+      return new Promise((resolve, reject) => {
+        const xhr = new XMLHttpRequest();
+        xhr.open("POST", url, true);
+        xhr.setRequestHeader("Content-Type", "application/json");
+        xhr.setRequestHeader("Authorization", `Bearer ${token}`);
+        xhr.onreadystatechange = () => {
+          if (xhr.readyState === 4) {
+            if (xhr.status === 200) {
+              resolve({
+                type: "xhr",
+                response: xhr.responseText
+              });
+            } else {
+              reject({
+                type: "xhr",
+                error: new Error(xhr.statusText)
+              });
+            }
+          }
+        };
+        xhr.send(JSON.stringify(data));
+      });
+    }
+    return new Promise((resolve, reject) => {
+      fetch(url, {
+        method: "POST",
+        body: JSON.stringify(data),
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`
+        }
+      }).then((res) => resolve({ type: "fetch", response: res })).catch((err) => reject({ type: "fetch", error: err }));
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HttpClient
+});