@lark-sentry/core 1.0.0 → 1.0.1

package/index.ts

@@ -0,0 +1,70 @@
+import { Status, type IOptions, type SentryPlugin } from "@lark-sentry/types";
+
+import { getBaseData, sentry } from "@lark-sentry/utils";
+
+import { DEFAULT_OPTIONS } from "@lark-sentry/constants";
+
+import { handleError } from "./src/handlers.js";
+import setup from "./src/setup.js";
+
+import { type Plugin, type ComponentPublicInstance } from "vue";
+import { Component, type ErrorInfo } from "react";
+import { EventType } from "@lark-sentry/types/dist/index.cjs";
+
+function init(
+  options: Partial<Omit<IOptions, "dsn">> & NonNullable<Pick<IOptions, "dsn">>,
+) {
+  sentry.setOptions({ ...DEFAULT_OPTIONS, ...options });
+  const { dsn } = sentry.options;
+  if (dsn === "") {
+    console.error("[lark-sentry] dsn is empty");
+    return;
+  }
+  setup();
+}
+
+const vuePlugin: Plugin = (app, options: IOptions) => {
+  const handler = app.config.errorHandler;
+  app.config.errorHandler = (
+    err: unknown,
+    vueInstance: ComponentPublicInstance | null,
+    info: string,
+  ) => {
+    handleError({
+      ...getBaseData(),
+      type: EventType.Vue,
+      status: Status.Error,
+      extra: err,
+    });
+    if (handler) {
+      handler.call(null, err, vueInstance, info);
+    }
+  };
+  init(options);
+};
+
+class ReactErrorBoundary extends Component {
+  override componentDidCatch(error: Error, errorInfo: ErrorInfo): void {
+    handleError({
+      ...getBaseData(),
+      type: EventType.React,
+      status: Status.Error,
+      extra: {
+        error,
+        errorInfo,
+      },
+    });
+  }
+}
+
+function use<T extends SentryPlugin, U = unknown>(
+  Plugin: new (options?: U) => T,
+  options?: U,
+) {
+  const plugin = new Plugin(options);
+  plugin.init();
+}
+
+export { init, vuePlugin, use, ReactErrorBoundary };
+
+// init({ dsn: "http://localhost:3000" });

package/package.json

@@ -1,24 +1,8 @@
 {
   "name": "@lark-sentry/core",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Sentry sdk core",
   "type": "module",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
   "keywords": [
     "sentry",
     "sdk",
@@ -27,10 +11,10 @@
   "author": "github.com/161043261",
   "license": "MIT",
   "dependencies": {
-    "@lark-sentry/constants": "^1.0.0",
-    "@lark-sentry/utils": "^1.0.0",
-    "@lark-sentry/reporter": "^1.0.0",
-    "@lark-sentry/types": "^1.0.0"
+    "@lark-sentry/constants": "^1.0.1",
+    "@lark-sentry/utils": "^1.0.1",
+    "@lark-sentry/reporter": "^1.0.1",
+    "@lark-sentry/types": "^1.0.1"
   },
   "devDependencies": {
     "@types/react": "^19.2.7",

package/package.prod.json

@@ -0,0 +1,39 @@
+{
+  "name": "@lark-sentry/core",
+  "version": "1.0.0",
+  "description": "Sentry sdk core",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": ["dist"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": ["sentry", "sdk", "core"],
+  "author": "github.com/161043261",
+  "license": "MIT",
+  "dependencies": {
+    "@lark-sentry/constants": "workspace:^",
+    "@lark-sentry/reporter": "workspace:^",
+    "@lark-sentry/types": "workspace:^",
+    "@lark-sentry/utils": "workspace:^"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "react": "^19.2.3",
+    "vue": "^3.5.26"
+  },
+  "peerDependencies": {
+    "react": "^19.2.3",
+    "vue": "^3.5.26"
+  }
+}

package/src/breadcrumb.ts

@@ -0,0 +1,26 @@
+import type { IBreadcrumbItem } from "@lark-sentry/types";
+
+import { MinHeap, sentry } from "@lark-sentry/utils";
+
+export class Breadcrumb extends MinHeap<IBreadcrumbItem> {
+  static #instance: Breadcrumb;
+
+  public static get instance() {
+    if (!Breadcrumb.#instance) {
+      Breadcrumb.#instance = new Breadcrumb();
+    }
+    return Breadcrumb.#instance;
+  }
+
+  override push(data: IBreadcrumbItem) {
+    const { onBeforePushBreadcrumb } = sentry.options;
+    if (onBeforePushBreadcrumb) {
+      data = onBeforePushBreadcrumb(data);
+    }
+    return super.push(data);
+  }
+}
+
+const breadcrumb = Breadcrumb.instance;
+
+export default breadcrumb;

package/src/bus.ts

@@ -0,0 +1,31 @@
+import {
+  EventType,
+  type IPub,
+  type ISub,
+  type TEventHandler,
+} from "@lark-sentry/types";
+
+const event2handlers = new Map<EventType, Set<TEventHandler>>();
+
+export const pub: IPub = (type, data) => {
+  const handlers = event2handlers.get(type);
+  if (!handlers) {
+    return;
+  }
+  try {
+    for (const handler of handlers) {
+      handler(data);
+    }
+  } catch (err) {
+    console.log("[lark-sentry] error", err);
+  }
+};
+
+export const sub: ISub = (type, handler) => {
+  const handlers = event2handlers.get(type);
+  if (!handlers) {
+    event2handlers.set(type, new Set([handler]));
+    return;
+  }
+  handlers.add(handler);
+};

package/src/decorate-publish.ts

@@ -0,0 +1,276 @@
+import {
+  EventType,
+  HttpMethod,
+  HttpStatusCode,
+  type IHttpData,
+  type WithSentry,
+} from "@lark-sentry/types";
+
+import {
+  throttle,
+  sentry,
+  decorateProp,
+  getBaseData,
+  isExcludedApi,
+} from "@lark-sentry/utils";
+
+import { pub } from "./bus.js";
+
+function decoratePublish(type: EventType) {
+  switch (type) {
+    case EventType.Click: {
+      pubClick();
+      break;
+    }
+
+    case EventType.Error: {
+      pubError();
+      break;
+    }
+
+    case EventType.Xhr: {
+      pubXhr();
+      break;
+    }
+
+    case EventType.Fetch: {
+      pubFetch();
+      break;
+    }
+
+    case EventType.History: {
+      pubHistory();
+      break;
+    }
+
+    case EventType.UnhandledRejection: {
+      pubUnhandledRejection();
+      break;
+    }
+
+    case EventType.HashChange: {
+      pubHashChange();
+      break;
+    }
+
+    case EventType.WhiteScreen: {
+      pubWhiteScreen();
+      break;
+    }
+
+    default: {
+      break;
+    }
+  }
+}
+
+function pubClick() {
+  const throttledPub = throttle(pub, sentry.options.clickThrottleDelay);
+  document.addEventListener("click", function (ctx: MouseEvent) {
+    // publish
+    throttledPub(EventType.Click, {
+      ...getBaseData(),
+      type: EventType.Click,
+      extra: ctx,
+    });
+  });
+}
+
+function pubError() {
+  globalThis.addEventListener("error", function (ctx: ErrorEvent) {
+    // publish
+    pub(EventType.Error, {
+      ...getBaseData(),
+      type: EventType.Error,
+      extra: ctx,
+    });
+  });
+}
+
+function pubXhr() {
+  type TXhrProtoOpen = (
+    method: string,
+    url: string,
+    async?: boolean,
+    ...rest: string[]
+  ) => void;
+
+  const xhrProto = XMLHttpRequest.prototype;
+
+  decorateProp(xhrProto, "open", (oldPropVal: TXhrProtoOpen) => {
+    return function (
+      this: WithSentry<XMLHttpRequest, IHttpData>,
+      method: string,
+      url: string,
+      async?: boolean,
+      ...rest: string[]
+    ) {
+      const httpData: IHttpData = {
+        ...getBaseData(),
+        name: "XMLHttpRequest",
+        type: EventType.Xhr,
+        method: method.toUpperCase(),
+        api: url,
+        elapsedTime: 0,
+        statusCode: HttpStatusCode.OK,
+      };
+      this.__sentry__ = httpData;
+      return oldPropVal.call(this, method, url, async, ...rest);
+    };
+  });
+
+  decorateProp(xhrProto, "send", (oldPropVal) => {
+    return function (
+      this: WithSentry<XMLHttpRequest, IHttpData>,
+      body?: Document | XMLHttpRequestBodyInit | null | undefined,
+    ) {
+      const { method, api } = this.__sentry__;
+      this.addEventListener("loadend", () => {
+        if (
+          (method.toUpperCase() === HttpMethod.Post &&
+            api === sentry.options.dsn) ||
+          isExcludedApi(api)
+        ) {
+          return;
+        }
+        const { status, responseType, response } = this;
+        this.__sentry__.statusCode = status;
+        this.__sentry__.requestData = { body };
+        this.__sentry__.responseData = {
+          responseType,
+          response,
+        };
+        const endTime = Date.now();
+        this.__sentry__.elapsedTime = endTime - this.__sentry__.timestamp;
+
+        // publish
+        pub(EventType.Xhr, this.__sentry__);
+      });
+      return oldPropVal.call(this, body);
+    };
+  });
+}
+
+function pubFetch() {
+  decorateProp(globalThis, "fetch", (oldPropVal) => {
+    return async function (
+      url: RequestInfo | URL,
+      options?: RequestInit | undefined,
+    ) {
+      const method = options?.method?.toUpperCase() ?? HttpMethod.Get;
+      const httpData: IHttpData = {
+        ...getBaseData(),
+        type: EventType.Fetch,
+        method,
+        requestData: { body: options?.body },
+        name: "Fetch",
+        api: url.toString(),
+        elapsedTime: 0,
+        statusCode: HttpStatusCode.OK,
+      };
+      return oldPropVal.call(globalThis, url, options).then((res: Response) => {
+        const resClone = res.clone();
+        const endTime = Date.now();
+        httpData.elapsedTime = endTime - httpData.timestamp;
+        httpData.statusCode = resClone.status;
+        resClone.text().then((res: string) => {
+          if (
+            (method === HttpMethod.Post &&
+              url.toString() === sentry.options.dsn) ||
+            isExcludedApi(url.toString())
+          ) {
+            return;
+          }
+          httpData.responseData = res;
+
+          // publish
+          pub(EventType.Fetch, httpData);
+        });
+        return res;
+      });
+    };
+  });
+}
+
+let latestHref = document.location.href;
+function pubHistory() {
+  const oldOnpopstate = globalThis.onpopstate;
+  if (typeof oldOnpopstate !== "function") {
+    return;
+  }
+
+  globalThis.onpopstate = function (this: Window, ev: PopStateEvent) {
+    const from = latestHref;
+    const to = document.location.href;
+    latestHref = to;
+    pub(EventType.History, {
+      ...getBaseData(),
+      type: EventType.History,
+      from,
+      to,
+    });
+    return oldOnpopstate.call(this, ev);
+  };
+
+  const historyDecorator = (oldPropsVal: History["pushState"]) => {
+    return function (
+      this: History,
+      data: unknown,
+      unused: string,
+      url?: string | URL | null,
+    ) {
+      if (url) {
+        const from = latestHref;
+        const to = url.toString();
+        latestHref = to;
+
+        // publish
+        pub(EventType.History, {
+          ...getBaseData(),
+          type: EventType.History,
+          from,
+          to,
+        });
+      }
+      return oldPropsVal.call(this, data, unused, url);
+    };
+  };
+  decorateProp(globalThis.history, "pushState", historyDecorator);
+  decorateProp(globalThis.history, "replaceState", historyDecorator);
+}
+
+function pubUnhandledRejection() {
+  globalThis.addEventListener(
+    "unhandledrejection",
+    function (ctx: PromiseRejectionEvent) {
+      // publish
+      pub(EventType.UnhandledRejection, {
+        ...getBaseData(),
+        type: EventType.UnhandledRejection,
+        extra: ctx,
+      });
+    },
+  );
+}
+
+function pubHashChange() {
+  globalThis.addEventListener("hashchange", function (ctx: HashChangeEvent) {
+    // publish
+    pub(EventType.HashChange, {
+      ...getBaseData(),
+      type: EventType.HashChange,
+      extra: ctx,
+    });
+  });
+}
+
+function pubWhiteScreen() {
+  // publish
+  pub(EventType.WhiteScreen, {
+    ...getBaseData(),
+    type: EventType.WhiteScreen,
+    extra: "WhiteScreen",
+  });
+}
+
+export default decoratePublish;

package/src/handlers.ts

@@ -0,0 +1,230 @@
+import {
+  EventType,
+  Status,
+  type IReportPayload,
+  type ICodeError,
+  type IHttpData,
+  type IRouteData,
+  type IResourceError,
+  type TEventHandler,
+  type IBaseDataWithEvent,
+} from "@lark-sentry/types";
+
+import {
+  sentry,
+  getBaseData,
+  event2breadcrumb,
+  base64v2,
+  transformHttpData,
+  dom2str,
+  isIExtendedErrorEvent,
+  isErrorEvent,
+  isError,
+} from "@lark-sentry/utils";
+
+import { UNKNOWN } from "@lark-sentry/constants";
+
+import reporter from "@lark-sentry/reporter";
+
+import breadcrumb from "./breadcrumb.js";
+import checkWhiteScreen from "./white-screen.js";
+
+const handleHttp: TEventHandler<IHttpData> = (data: IHttpData) => {
+  data = transformHttpData(data);
+  const { id, name, time, timestamp, message, status, type } = data;
+  if (!data.api.includes(sentry.options.dsn)) {
+    breadcrumb.push({
+      id,
+      name,
+      time,
+      timestamp,
+      message,
+      status,
+      type,
+      userAction: event2breadcrumb(type),
+    });
+  }
+  if (status === Status.Error) {
+    reporter.send(data);
+  }
+};
+
+const handleError: TEventHandler<IBaseDataWithEvent> = ({
+  extra: err,
+  ...rest
+}) => {
+  if (isErrorEvent(err)) {
+    handleCodeError(err);
+  }
+
+  if (isIExtendedErrorEvent(err)) {
+    const { localName, src, href } = err.target;
+    const { message } = err;
+    const resourceError: IResourceError = {
+      ...rest,
+      type: EventType.Resource,
+      status: Status.Error,
+      name: localName,
+      src,
+      href,
+      message,
+    };
+    breadcrumb.push({
+      ...resourceError,
+      userAction: event2breadcrumb(EventType.Resource),
+    });
+    reporter.send(resourceError);
+    return;
+  }
+
+  if (isError(err)) {
+    const { name, message } = err;
+    const data: IBaseDataWithEvent = {
+      ...rest,
+      type: EventType.Error,
+      name,
+      message,
+      status: Status.Error,
+      extra: err,
+    };
+    breadcrumb.push({
+      ...data,
+      userAction: event2breadcrumb(EventType.Error),
+    });
+    reporter.send(data);
+    return;
+  }
+
+  // Unknown error
+  const data: IBaseDataWithEvent = {
+    ...rest,
+    type: EventType.Error,
+    name: "Unknown Error",
+    message: JSON.stringify(err),
+    status: Status.Error,
+    extra: err,
+  };
+  breadcrumb.push({
+    ...data,
+    userAction: event2breadcrumb(EventType.Error),
+  });
+  reporter.send(data);
+};
+
+const handleHistory: TEventHandler<IRouteData> = ({
+  from,
+  to,
+  ...rest
+}: IRouteData) => {
+  const routeChange = `${from} => ${to}`;
+  const routeData: IRouteData = {
+    ...rest,
+    name: routeChange,
+    message: routeChange,
+    type: EventType.History,
+    from,
+    to,
+  };
+  breadcrumb.push({
+    ...routeData,
+    userAction: event2breadcrumb(EventType.History),
+  });
+};
+
+const handleHashChange: TEventHandler<IBaseDataWithEvent> = ({
+  extra,
+  ...rest
+}: IBaseDataWithEvent) => {
+  const { oldURL: from = UNKNOWN, newURL: to = UNKNOWN } =
+    extra as HashChangeEvent;
+  const pathChange = `${from} => ${to}`;
+  const routeData: IRouteData = {
+    ...rest,
+    name: pathChange,
+    message: pathChange,
+    type: EventType.HashChange,
+    from,
+    to,
+  };
+  breadcrumb.push({
+    ...routeData,
+    userAction: event2breadcrumb(EventType.HashChange),
+  });
+};
+
+const handleUnhandledRejection: TEventHandler<IBaseDataWithEvent> = (
+  data: IBaseDataWithEvent,
+) => {
+  if (!isIExtendedErrorEvent(data.extra)) {
+    handleError(data);
+    return;
+  }
+  handleCodeError(data.extra);
+};
+
+const handleWhiteScreen: TEventHandler<IBaseDataWithEvent> = (
+  data: IBaseDataWithEvent,
+) => {
+  checkWhiteScreen(() => {
+    reporter.send(data);
+  });
+  return;
+};
+
+const handleClick: TEventHandler<IBaseDataWithEvent> = ({
+  extra,
+  ...rest
+}: IBaseDataWithEvent) => {
+  const typedEvent = extra as PointerEvent;
+  const str =
+    typedEvent.target instanceof HTMLElement ? dom2str(typedEvent.target) : "";
+  breadcrumb.push({
+    ...rest,
+    type: EventType.Click,
+    name: str,
+    message: str,
+    userAction: event2breadcrumb(EventType.Click),
+  });
+};
+
+export {
+  handleError,
+  handleHistory,
+  handleHashChange,
+  handleHttp,
+  handleUnhandledRejection,
+  handleWhiteScreen,
+  handleClick,
+};
+
+const handleCodeError = (err: ErrorEvent) => {
+  const { filename, colno: column, lineno: line, message } = err;
+  const data: IReportPayload = {
+    ...getBaseData(),
+    type: EventType.Error,
+    name: filename,
+    message,
+    status: Status.Error,
+  };
+  const codeError: ICodeError = {
+    ...data,
+    column,
+    line,
+  };
+  breadcrumb.push({
+    ...data,
+    userAction: event2breadcrumb(EventType.Error),
+  });
+
+  const errorId = base64v2(
+    `${EventType.Error}-${message}-${filename}-${line}-${column}`,
+  );
+  if (
+    errorId.includes(UNKNOWN) ||
+    sentry.options.repeatCodeError ||
+    (!sentry.options.repeatCodeError && !sentry.codeErrors.has(errorId))
+  ) {
+    sentry.codeErrors.add(errorId);
+    reporter.send(codeError);
+  }
+};