@orbitai/orbitrace 1.2.1 → 1.4.0

package/dist/browser.mjs

@@ -0,0 +1,525 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/shared.js
+var require_shared = __commonJS({
+  "src/shared.js"(exports, module) {
+    var REQUEST_TIMEOUT_MS = 5e3;
+    var DEDUPE_WINDOW_MS = 1e4;
+    var MAX_IN_FLIGHT = 10;
+    var DEFAULT_RETRY_AFTER_SECONDS = 60;
+    var MAX_BREADCRUMBS = 30;
+    var MAX_BREADCRUMB_MESSAGE_LENGTH = 200;
+    var BREADCRUMB_LEVELS = ["debug", "info", "warning", "error"];
+    var CONSOLE_LEVELS = { debug: "debug", log: "info", info: "info", warn: "warning", error: "error" };
+    var SENSITIVE_KEY_PARTS = [
+      "password",
+      "passwd",
+      "secret",
+      "token",
+      "authorization",
+      "cookie",
+      "apikey",
+      "privatekey",
+      "credential",
+      "session"
+    ];
+    var FILTERED_VALUE = "[Filtered]";
+    function isSensitiveKey(key) {
+      const normalized = key.toLowerCase().replace(/[-_]/g, "");
+      return SENSITIVE_KEY_PARTS.some((part) => normalized.includes(part));
+    }
+    function filterSensitive(value, ancestors = /* @__PURE__ */ new WeakSet()) {
+      if (value === null || typeof value !== "object") {
+        return value;
+      }
+      if (ancestors.has(value)) {
+        return "[Circular]";
+      }
+      const isArray = Array.isArray(value);
+      const prototype = Object.getPrototypeOf(value);
+      if (!isArray && prototype !== Object.prototype && prototype !== null) {
+        return value;
+      }
+      ancestors.add(value);
+      const filtered = isArray ? value.map((item) => filterSensitive(item, ancestors)) : Object.fromEntries(
+        Object.entries(value).map(([key, item]) => [
+          key,
+          isSensitiveKey(key) ? FILTERED_VALUE : filterSensitive(item, ancestors)
+        ])
+      );
+      ancestors.delete(value);
+      return filtered;
+    }
+    function truncate(value, maxLength) {
+      return value.length > maxLength ? `${value.slice(0, maxLength)}...` : value;
+    }
+    function cleanUrl(url) {
+      try {
+        const parsed = new URL(url);
+        return `${parsed.origin}${parsed.pathname}`;
+      } catch {
+        return String(url).split(/[?#]/)[0];
+      }
+    }
+    function pushBreadcrumb(breadcrumbs, { category = "manual", message = "", level = "info", data } = {}) {
+      try {
+        breadcrumbs.push({
+          timestamp: Date.now(),
+          category: String(category).slice(0, 64),
+          level: BREADCRUMB_LEVELS.includes(level) ? level : "info",
+          message: truncate(String(message), MAX_BREADCRUMB_MESSAGE_LENGTH),
+          ...data !== void 0 && { data: filterSensitive(data) }
+        });
+        if (breadcrumbs.length > MAX_BREADCRUMBS) {
+          breadcrumbs.shift();
+        }
+      } catch {
+      }
+    }
+    function httpBreadcrumb({ method, url, status, error, started }) {
+      const data = { method, url: cleanUrl(url), durationMs: Date.now() - started };
+      if (error) {
+        return { category: "http", level: "error", message: `${method} ${data.url} failed`, data: { ...data, error } };
+      }
+      return {
+        category: "http",
+        level: status >= 500 ? "error" : status >= 400 ? "warning" : "info",
+        message: `${method} ${data.url} ${status}`,
+        data: { ...data, status }
+      };
+    }
+    function recordFetch({ endpoint, addBreadcrumb, restore }) {
+      if (typeof globalThis.fetch !== "function") {
+        return null;
+      }
+      const originalFetch = globalThis.fetch;
+      globalThis.fetch = async function orbitraceFetch(input, init) {
+        const url = typeof input === "string" || input instanceof URL ? String(input) : input?.url;
+        if (!url || url.startsWith(endpoint)) {
+          return originalFetch.call(this, input, init);
+        }
+        const method = String(init?.method || input?.method || "GET").toUpperCase();
+        const started = Date.now();
+        try {
+          const response = await originalFetch.call(this, input, init);
+          addBreadcrumb(httpBreadcrumb({ method, url, status: response.status, started }));
+          return response;
+        } catch (error) {
+          addBreadcrumb(httpBreadcrumb({ method, url, error: error?.message, started }));
+          throw error;
+        }
+      };
+      restore.push(() => {
+        globalThis.fetch = originalFetch;
+      });
+      return originalFetch;
+    }
+    function recordConsole({ format, addBreadcrumb, restore }) {
+      let recording = false;
+      for (const [method, level] of Object.entries(CONSOLE_LEVELS)) {
+        const original = console[method];
+        if (typeof original !== "function") {
+          continue;
+        }
+        console[method] = function orbitraceConsole(...args) {
+          if (!recording) {
+            recording = true;
+            try {
+              const message = format(args);
+              if (!message.startsWith("Orbitrace:")) {
+                addBreadcrumb({ category: "console", level, message });
+              }
+            } catch {
+            } finally {
+              recording = false;
+            }
+          }
+          return original.apply(this, args);
+        };
+        restore.push(() => {
+          console[method] = original;
+        });
+      }
+    }
+    var _endpoint, _headers, _getFetch, _requestOptions, _pending, _inFlight, _pausedUntil, _Sender_instances, flushPending_fn, canSend_fn, send_fn, post_fn;
+    var Sender = class {
+      // `getFetch` returns the fetch to use at send time, so a wrapped global fetch is never recorded.
+      // `requestOptions(body)` adds fetch options for one request, such as keepalive in browsers.
+      constructor({ endpoint, headers, getFetch = () => globalThis.fetch, requestOptions = () => ({}) }) {
+        __privateAdd(this, _Sender_instances);
+        __privateAdd(this, _endpoint);
+        __privateAdd(this, _headers);
+        __privateAdd(this, _getFetch);
+        __privateAdd(this, _requestOptions);
+        __privateAdd(this, _pending, /* @__PURE__ */ new Map());
+        __privateAdd(this, _inFlight, /* @__PURE__ */ new Set());
+        __privateAdd(this, _pausedUntil, 0);
+        __privateSet(this, _endpoint, endpoint);
+        __privateSet(this, _headers, headers);
+        __privateSet(this, _getFetch, getFetch);
+        __privateSet(this, _requestOptions, requestOptions);
+      }
+      // Queues the event and returns at once; it is sent in the background. flush() waits for delivery.
+      capture(event, payload) {
+        const key = JSON.stringify([event, payload.message, payload.stack ?? null]);
+        const pending = __privateGet(this, _pending).get(key);
+        if (pending) {
+          pending.count++;
+          return;
+        }
+        if (!__privateMethod(this, _Sender_instances, canSend_fn).call(this)) {
+          return;
+        }
+        const entry = { event, payload, count: 0 };
+        entry.timer = setTimeout(() => __privateMethod(this, _Sender_instances, flushPending_fn).call(this, key), DEDUPE_WINDOW_MS);
+        entry.timer.unref?.();
+        __privateGet(this, _pending).set(key, entry);
+        __privateMethod(this, _Sender_instances, send_fn).call(this, event, payload, 1);
+      }
+      // Sends counts still held by the dedupe window and waits for in-flight requests.
+      async flush() {
+        await Promise.all([...__privateGet(this, _pending).keys()].map((key) => __privateMethod(this, _Sender_instances, flushPending_fn).call(this, key)));
+        await Promise.all(__privateGet(this, _inFlight));
+      }
+    };
+    _endpoint = new WeakMap();
+    _headers = new WeakMap();
+    _getFetch = new WeakMap();
+    _requestOptions = new WeakMap();
+    _pending = new WeakMap();
+    _inFlight = new WeakMap();
+    _pausedUntil = new WeakMap();
+    _Sender_instances = new WeakSet();
+    flushPending_fn = async function(key) {
+      const entry = __privateGet(this, _pending).get(key);
+      if (!entry) {
+        return;
+      }
+      __privateGet(this, _pending).delete(key);
+      clearTimeout(entry.timer);
+      if (entry.count > 0 && __privateMethod(this, _Sender_instances, canSend_fn).call(this)) {
+        await __privateMethod(this, _Sender_instances, send_fn).call(this, entry.event, entry.payload, entry.count);
+      }
+    };
+    canSend_fn = function() {
+      return Date.now() >= __privateGet(this, _pausedUntil) && __privateGet(this, _inFlight).size < MAX_IN_FLIGHT;
+    };
+    send_fn = function(event, payload, count) {
+      const request = __privateMethod(this, _Sender_instances, post_fn).call(this, event, payload, count).finally(() => __privateGet(this, _inFlight).delete(request));
+      __privateGet(this, _inFlight).add(request);
+      return request;
+    };
+    post_fn = async function(event, payload, count) {
+      try {
+        const body = JSON.stringify({ event, ...count > 1 && { count }, payload });
+        const response = await __privateGet(this, _getFetch).call(this)(__privateGet(this, _endpoint), {
+          method: "POST",
+          headers: { "Content-Type": "application/json", ...__privateGet(this, _headers) },
+          body,
+          signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+          ...__privateGet(this, _requestOptions).call(this, body)
+        });
+        if (response.status === 429) {
+          const retryAfterSeconds = Number(response.headers.get("retry-after")) || DEFAULT_RETRY_AFTER_SECONDS;
+          __privateSet(this, _pausedUntil, Date.now() + retryAfterSeconds * 1e3);
+          console.warn(`Orbitrace: rate limited, dropping events for ${retryAfterSeconds}s`);
+          return;
+        }
+        if (!response.ok) {
+          console.error(`Orbitrace: API responded with status ${response.status}`);
+          return;
+        }
+        return await response.json();
+      } catch (error) {
+        console.error("Orbitrace: Error sending data to API", error.message);
+      }
+    };
+    module.exports = {
+      MAX_BREADCRUMB_MESSAGE_LENGTH,
+      Sender,
+      cleanUrl,
+      filterSensitive,
+      pushBreadcrumb,
+      recordConsole,
+      recordFetch,
+      truncate
+    };
+  }
+});
+
+// src/browser.js
+var require_browser = __commonJS({
+  "src/browser.js"(exports, module) {
+    var { Sender, cleanUrl, filterSensitive, pushBreadcrumb, recordConsole, recordFetch, truncate } = require_shared();
+    var MAX_KEEPALIVE_BODY_BYTES = 60 * 1024;
+    var MAX_CONSOLE_ARG_LENGTH = 200;
+    function formatConsoleArgs(args) {
+      return args.map((arg) => {
+        if (typeof arg === "string") {
+          return arg;
+        }
+        if (arg instanceof Error) {
+          return arg.stack || arg.message;
+        }
+        try {
+          return truncate(JSON.stringify(arg), MAX_CONSOLE_ARG_LENGTH);
+        } catch {
+          return String(arg);
+        }
+      }).join(" ");
+    }
+    function describeElement(element) {
+      if (!element || typeof element.tagName !== "string") {
+        return "unknown";
+      }
+      const tag = element.tagName.toLowerCase();
+      const id = element.id ? `#${element.id}` : "";
+      const classes = typeof element.className === "string" && element.className.trim() ? `.${element.className.trim().split(/\s+/).slice(0, 3).join(".")}` : "";
+      return `${tag}${id}${classes}`;
+    }
+    var _config, _sender, _breadcrumbs, _user, _restore, _fetch, _Orbitrace_static, autoCaptureOptions_fn, installAutoCapture_fn, capture_fn;
+    var _Orbitrace = class _Orbitrace {
+      // Automatic capture is on unless autoCapture is false or parts of it are switched off.
+      static init(config) {
+        this.assertBrowserRuntime();
+        this.validateConfig(config);
+        this.close();
+        __privateSet(this, _config, {
+          orgId: config.orgId,
+          projectId: config.projectId,
+          endpoint: config.endpoint,
+          environment: config.environment || "production",
+          version: config.version || "1.0.0",
+          service: config.service || "browser",
+          disabled: config.disabled || false
+        });
+        __privateSet(this, _sender, new Sender({
+          endpoint: config.endpoint,
+          headers: {
+            "x-orbitrace-api-key": config.publicKey,
+            "x-orbitrace-org-id": config.orgId,
+            "x-orbitrace-project-id": config.projectId
+          },
+          // Orbitrace's own requests use the original fetch, so they are never recorded.
+          getFetch: () => __privateGet(this, _fetch) || window.fetch.bind(window),
+          requestOptions: (body) => ({ keepalive: body.length <= MAX_KEEPALIVE_BODY_BYTES })
+        }));
+        const autoCapture = __privateMethod(this, _Orbitrace_static, autoCaptureOptions_fn).call(this, config.autoCapture);
+        if (autoCapture && !__privateGet(this, _config).disabled) {
+          __privateMethod(this, _Orbitrace_static, installAutoCapture_fn).call(this, autoCapture);
+        }
+      }
+      static validateConfig(config) {
+        if (config.apiKey) {
+          throw new Error(
+            "Orbitrace: apiKey is a server secret and must not ship in a browser bundle; use the project's publicKey"
+          );
+        }
+        const requiredFields = ["publicKey", "orgId", "projectId", "endpoint"];
+        const missingFields = requiredFields.filter((field) => !config[field]);
+        if (missingFields.length > 0) {
+          throw new Error(`Missing required configuration fields: ${missingFields.join(", ")}`);
+        }
+      }
+      static assertBrowserRuntime() {
+        if (typeof window === "undefined" || typeof document === "undefined") {
+          throw new Error("Orbitrace: @orbitai/orbitrace/browser runs in browsers; use @orbitai/orbitrace on servers");
+        }
+      }
+      // Queues the event and returns at once; it is sent in the background. flush() waits for delivery.
+      static captureException(error, metadata = {}) {
+        const message = error?.message || error?.name || String(error);
+        __privateMethod(this, _Orbitrace_static, capture_fn).call(this, "capture_exception", {
+          message,
+          stack: error?.stack || message,
+          metadata
+        });
+      }
+      static captureMessage(message, metadata = {}) {
+        __privateMethod(this, _Orbitrace_static, capture_fn).call(this, "capture_message", { message, metadata });
+      }
+      // Records something that happened, sent with the next event.
+      static addBreadcrumb(breadcrumb) {
+        pushBreadcrumb(__privateGet(this, _breadcrumbs), breadcrumb);
+      }
+      // Identifies the signed-in user on every following event. Send a stable id, not personal data.
+      // Pass null when the user signs out.
+      static setUser(user) {
+        __privateSet(this, _user, user ? filterSensitive(user) : null);
+      }
+      // Sends counts still held by the dedupe window and waits for in-flight requests.
+      static async flush() {
+        await __privateGet(this, _sender)?.flush();
+      }
+      // Removes the listeners and wrappers automatic capture installed and forgets breadcrumbs and the user.
+      static close() {
+        for (const undo of __privateGet(this, _restore).splice(0).reverse()) {
+          try {
+            undo();
+          } catch {
+          }
+        }
+        __privateSet(this, _fetch, null);
+        __privateSet(this, _breadcrumbs, []);
+        __privateSet(this, _user, null);
+      }
+      // Vue 3 plugin: app.use(Orbitrace.vue). Errors Vue catches in components are captured with the component
+      // name and where Vue caught them, then passed to the handler the app had, or logged as Vue would.
+      static get vue() {
+        return {
+          install(app) {
+            const previous = app.config.errorHandler;
+            app.config.errorHandler = (error, instance, info) => {
+              _Orbitrace.captureException(error, {
+                mechanism: "vue",
+                component: instance?.$options?.name || instance?.$?.type?.__name || "anonymous",
+                info
+              });
+              if (previous) {
+                previous(error, instance, info);
+              } else {
+                console.error(error);
+              }
+            };
+          }
+        };
+      }
+    };
+    _config = new WeakMap();
+    _sender = new WeakMap();
+    _breadcrumbs = new WeakMap();
+    _user = new WeakMap();
+    _restore = new WeakMap();
+    _fetch = new WeakMap();
+    _Orbitrace_static = new WeakSet();
+    autoCaptureOptions_fn = function(value) {
+      if (value === false) {
+        return null;
+      }
+      const options = value === true || value === void 0 ? {} : value;
+      return {
+        exceptions: options.exceptions !== false,
+        console: options.console !== false,
+        fetch: options.fetch !== false,
+        clicks: options.clicks !== false,
+        navigation: options.navigation !== false
+      };
+    };
+    installAutoCapture_fn = function(options) {
+      const addBreadcrumb = (breadcrumb) => this.addBreadcrumb(breadcrumb);
+      const listen = (target, type, listener, capture = false) => {
+        target.addEventListener(type, listener, capture);
+        __privateGet(this, _restore).push(() => target.removeEventListener(type, listener, capture));
+      };
+      if (options.exceptions) {
+        listen(window, "error", (event) => {
+          const error = event.error ?? new Error(event.message || "Unknown error");
+          this.captureException(error, {
+            mechanism: "onerror",
+            ...event.filename && { source: `${cleanUrl(event.filename)}:${event.lineno}:${event.colno}` }
+          });
+        });
+        listen(window, "unhandledrejection", (event) => {
+          const reason = event.reason;
+          const error = reason instanceof Error ? reason : new Error(`Unhandled rejection: ${formatConsoleArgs([reason])}`);
+          this.captureException(error, { mechanism: "unhandledrejection" });
+        });
+      }
+      if (options.console) {
+        recordConsole({ addBreadcrumb, restore: __privateGet(this, _restore), format: formatConsoleArgs });
+      }
+      if (options.fetch) {
+        __privateSet(this, _fetch, recordFetch({ endpoint: __privateGet(this, _config).endpoint, addBreadcrumb, restore: __privateGet(this, _restore) }));
+      }
+      if (options.clicks) {
+        listen(
+          document,
+          "click",
+          (event) => addBreadcrumb({ category: "ui.click", message: describeElement(event.target) }),
+          true
+        );
+      }
+      if (options.navigation) {
+        let from = cleanUrl(window.location.href);
+        const navigated = () => {
+          const to = cleanUrl(window.location.href);
+          if (to !== from) {
+            addBreadcrumb({ category: "navigation", message: `${from} -> ${to}`, data: { from, to } });
+            from = to;
+          }
+        };
+        for (const method of ["pushState", "replaceState"]) {
+          const original = window.history[method];
+          if (typeof original !== "function") {
+            continue;
+          }
+          window.history[method] = function orbitraceHistory(...args) {
+            const result = original.apply(this, args);
+            navigated();
+            return result;
+          };
+          __privateGet(this, _restore).push(() => {
+            window.history[method] = original;
+          });
+        }
+        listen(window, "popstate", navigated);
+        listen(window, "hashchange", navigated);
+      }
+      listen(window, "pagehide", () => __privateGet(this, _sender).flush());
+    };
+    capture_fn = function(event, { metadata, ...fields }) {
+      if (!__privateGet(this, _config)) {
+        console.error("Orbitrace: call Orbitrace.init() before capturing events");
+        return;
+      }
+      if (__privateGet(this, _config).disabled) {
+        return;
+      }
+      try {
+        const breadcrumbs = [...__privateGet(this, _breadcrumbs)];
+        __privateGet(this, _sender).capture(event, {
+          ...fields,
+          metadata: {
+            ...filterSensitive(metadata),
+            env: __privateGet(this, _config).environment,
+            version: __privateGet(this, _config).version,
+            service: __privateGet(this, _config).service,
+            ...__privateGet(this, _user) && { user: __privateGet(this, _user) },
+            // Where it happened. URLs lose their query string and fragment.
+            page: {
+              url: cleanUrl(window.location.href),
+              ...document.referrer && { referrer: cleanUrl(document.referrer) },
+              viewport: `${window.innerWidth}x${window.innerHeight}`,
+              language: window.navigator?.language
+            }
+          },
+          ...breadcrumbs.length > 0 && { breadcrumbs }
+        });
+      } catch (error) {
+        console.error("Orbitrace: could not capture the event", error?.message);
+      }
+    };
+    __privateAdd(_Orbitrace, _Orbitrace_static);
+    __privateAdd(_Orbitrace, _config, null);
+    __privateAdd(_Orbitrace, _sender, null);
+    __privateAdd(_Orbitrace, _breadcrumbs, []);
+    __privateAdd(_Orbitrace, _user, null);
+    // Undo functions for everything automatic capture installed; close() runs them.
+    __privateAdd(_Orbitrace, _restore, []);
+    __privateAdd(_Orbitrace, _fetch, null);
+    var Orbitrace = _Orbitrace;
+    module.exports = Orbitrace;
+  }
+});
+export default require_browser();