@pluve/logger-sdk 0.0.7 → 0.0.8

package/dist/esm/capture/resourceError.js

@@ -0,0 +1,24 @@
+// src/capture/resourceError.ts
+import { logDebug } from "../utils/tools";
+function registerResourceErrorCapture(debug, callback) {
+  if (typeof window === "undefined")
+    return void 0;
+  const handler = (e) => {
+    var _a;
+    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);
+}
+export {
+  registerResourceErrorCapture
+};

package/dist/esm/capture/wechatError.js

@@ -0,0 +1,92 @@
+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/capture/wechatError.ts
+import { parseStack } from "../stack/stacktrace";
+import { isWeChatMiniProgram } from "../utils/environment";
+import { logDebug } from "../utils/tools";
+function registerWechatErrorCapture(debug, callback) {
+  if (!isWeChatMiniProgram())
+    return void 0;
+  try {
+    const wxAny = globalThis.wx;
+    if (wxAny && typeof wxAny.onError === "function") {
+      const handler = (error) => __async(this, null, function* () {
+        var _a;
+        logDebug(debug, "registerWechatErrorCapture onError", error);
+        const msg = String((_a = error == null ? void 0 : error.message) != null ? _a : error);
+        const err = error instanceof Error ? error : new Error(msg);
+        const stack = yield parseStack(err);
+        callback({
+          type: "js",
+          message: err.message,
+          stack,
+          throwable: err.stack || ""
+        });
+      });
+      wxAny.onError(handler);
+      return () => {
+        try {
+          wxAny.offError && wxAny.offError(handler);
+        } catch (e) {
+        }
+      };
+    }
+  } catch (e) {
+    logDebug(debug, "registerWechatErrorCapture attach failed", e);
+  }
+  return void 0;
+}
+function registerWechatUnhandledCapture(debug, callback) {
+  if (!isWeChatMiniProgram())
+    return void 0;
+  try {
+    const wxAny = globalThis.wx;
+    if (wxAny && typeof wxAny.onUnhandledRejection === "function") {
+      const handler = (res) => __async(this, null, function* () {
+        const reason = res == null ? void 0 : res.reason;
+        logDebug(debug, "registerWechatUnhandledCapture onUnhandledRejection", reason);
+        const err = reason instanceof Error ? reason : new Error(String(reason));
+        const stack = yield parseStack(err);
+        callback({
+          type: "promise",
+          message: err.message,
+          stack,
+          throwable: err.stack || ""
+        });
+      });
+      wxAny.onUnhandledRejection(handler);
+      return () => {
+        try {
+          wxAny.offUnhandledRejection && wxAny.offUnhandledRejection(handler);
+        } catch (e) {
+        }
+      };
+    }
+  } catch (e) {
+    logDebug(debug, "registerWechatUnhandledCapture attach failed", e);
+  }
+  return void 0;
+}
+export {
+  registerWechatErrorCapture,
+  registerWechatUnhandledCapture
+};

package/dist/esm/compress/compression.js

@@ -0,0 +1,82 @@
+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/compress/compression.ts
+import { gzipSync } from "fflate";
+import { Base64 } from "js-base64";
+import { isBrowser } from "../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);
+}
+function gzipCompress(data) {
+  return __async(this, null, function* () {
+    if (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 = yield 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 = gzipSync(input);
+      return Base64.fromUint8Array(compressed, false);
+    } catch (e) {
+      console.log("gzipCompress 压缩失败", e);
+    }
+    return Base64.encode(data, false);
+  });
+}
+function isGzipSupported() {
+  return isBrowser() && typeof CompressionStream !== "undefined";
+}
+export {
+  gzipCompress,
+  isGzipSupported
+};

package/dist/esm/config/index.js

@@ -0,0 +1,28 @@
+// src/config/index.ts
+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`;
+};
+export {
+  getPixelBatchApi,
+  getRegisterApi,
+  getReportApi,
+  getSDKBaseApi
+};

package/dist/esm/core/fingerprint.js

@@ -0,0 +1,12 @@
+// src/core/fingerprint.ts
+import { normalizeMessage } from "../utils/tools";
+function generateFingerprint(error) {
+  var _a;
+  const msg = 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}`;
+}
+export {
+  generateFingerprint
+};

package/dist/esm/core/httpClient.js

@@ -0,0 +1,95 @@
+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/httpClient.ts
+import { isWeChatMiniProgram } from "../utils/environment";
+import { logDebug } from "../utils/tools";
+var HttpClient = class {
+  /**
+   * 发送 POST 请求,需要兼容浏览器和微信小程序
+   */
+  static post(url, data, token) {
+    return __async(this, null, function* () {
+      logDebug(true, "post", url, data, token);
+      if (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 }));
+      });
+    });
+  }
+};
+export {
+  HttpClient
+};