@orbitai/orbitrace 1.2.0 → 1.3.0

package/README.md

@@ -1,8 +1,8 @@
 # @orbitai/orbitrace
 
-Error tracking and monitoring for backend Node.js applications.
+Error tracking and monitoring for Node.js services and browser apps.
 
-Orbitrace is server-side only. Do not initialize this package in browser or frontend code, because the Orbitrace API key is a backend secret and must not be exposed in public bundles.
+The package has two entries. `@orbitai/orbitrace` runs on servers with the project's API key, which is a secret. `@orbitai/orbitrace/browser` runs in browsers with the project's public key, which is accepted only from the origins allowed in the Orbitrace dashboard. Never put the API key in a browser bundle; the server entry throws if it is loaded in a browser.
 
 ## Installation
 
@@ -47,7 +47,7 @@ const orbitrace = getOrbitraceInstance({ service: "api" });
 try {
 	// Your code here
 } catch (error) {
-	await orbitrace.captureException(error, {
+	orbitrace.captureException(error, {
 		endpoint: "/users",
 		action: "createUser",
 	});
@@ -57,15 +57,16 @@ try {
 ### 3. Capture Messages
 
 ```javascript
-await orbitrace.captureMessage("User registered", {
+orbitrace.captureMessage("User registered", {
 	userId: "123",
 });
 ```
 
 ### 4. Delivery Behavior
 
-Orbitrace never throws and never blocks your application for long:
+Orbitrace never throws and never blocks your application:
 
+- `captureException` and `captureMessage` return as soon as the event is queued. The request is sent in the background, so a request handler that captures an error does not wait for Orbitrace before answering its own client. Awaiting them is harmless but waits for nothing; use `flush()` when you need to know the events were delivered.
 - Each request times out after 5 seconds. Failures are logged to the console and swallowed.
 - Repeats of the same event (same message and stack) within 10 seconds are counted locally and sent as one request with an occurrence count, so an error raised in a loop costs at most two requests per 10 seconds.
 - At most 10 requests are in flight at once; events beyond that are dropped.
@@ -79,7 +80,7 @@ await orbitrace.flush();
 
 ### 5. Automatic Capture
 
-Pass `autoCapture: true` to `getInstance` (SDK 1.2.0 or newer) to capture what nobody handled and record breadcrumbs automatically. It is off unless you turn it on, so upgrading never changes how an application crashes or logs.
+Pass `autoCapture: true` to `getInstance` (SDK 1.2.1 or newer) to capture what nobody handled and record breadcrumbs automatically. It is off unless you turn it on, so upgrading never changes how an application crashes or logs.
 
 ```javascript
 orbitrace.getInstance({ ...config, autoCapture: true });
@@ -130,6 +131,43 @@ exports.checkout = onRequest(orbitrace.wrap(async (req, res) => {
 }));
 ```
 
+## Browser Setup
+
+Install the same package and import the browser entry. It needs a browser with `fetch`, so every current browser.
+
+```javascript
+import Orbitrace from "@orbitai/orbitrace/browser";
+
+Orbitrace.init({
+	publicKey: "the project's public key",
+	orgId: "your-org-id",
+	projectId: "your-project-id",
+	endpoint: "your-endpoint",
+	environment: import.meta.env.MODE,
+	version: "1.0.0",
+	service: "webapp",
+});
+```
+
+The public key can be read by anyone who opens your site. That is fine: it only creates events, the API accepts it only from the origins allowed for the project (dashboard, Documentation, Browser apps), and the project's rate limit and your organization's quota bound what it can do. `init` throws if it is given an `apiKey`.
+
+Automatic capture is on unless `autoCapture: false`. Uncaught errors and unhandled promise rejections are reported; breadcrumbs are recorded from `console` calls, `fetch` requests, clicks (the element, never its text) and navigation. Switch parts off with `autoCapture: { console: false, clicks: false }`; the parts are `exceptions`, `console`, `fetch`, `clicks` and `navigation`.
+
+`captureException`, `captureMessage`, `addBreadcrumb`, `flush` and `close` work as on servers. There are no scopes: one tab is one scope.
+
+```javascript
+// After sign-in, so issues show who was affected. Send a stable id, never personal data.
+Orbitrace.setUser({ id: user.uid });
+// On sign-out:
+Orbitrace.setUser(null);
+
+// Vue 3: errors Vue catches inside components are reported with the component name,
+// then passed to the app's own errorHandler, or logged as Vue would.
+app.use(Orbitrace.vue);
+```
+
+Every browser event carries `page`: the URL (without query string or fragment), referrer, viewport and language. Requests use `keepalive`, so an error reported just before the page closes still arrives. Production stacks are minified; issues still group correctly across deploys because file hashes and line numbers are ignored, so keep `version` set to your release to see which build introduced a problem.
+
 ## Data Collected
 
 Each event stores:
@@ -137,7 +175,7 @@ Each event stores:
 - The error message (truncated to 200 characters) and stack trace, or the message text.
 - The `metadata` object you pass, plus `env`, `version` and `service` from your configuration.
 - Breadcrumbs, when there are any: the last 30 recorded before the event.
-- The IP address and user agent of the server that sent the request, with an approximate location derived from that IP.
+- The IP address and user agent of the server that sent the request, with an approximate location derived from that IP. For browser events, the user agent and approximate location of the user; their IP address is not stored.
 
 Before sending, metadata values whose key contains `password`, `passwd`, `secret`, `token`, `authorization`, `cookie`, `apikey`, `privatekey`, `credential` or `session` (ignoring case, `-` and `_`) are replaced with `[Filtered]`, at any depth. Error messages and stack traces are sent as they are.
 
@@ -157,6 +195,6 @@ ORBITRACE_DISABLED=false
 
 ## Security Model
 
-Orbitrace authenticates ingestion requests with `ORBITRACE_API_KEY`. Keep this key only in backend environments such as servers, workers, functions, and CI jobs. Do not use `VITE_`, `NEXT_PUBLIC_`, or other public frontend environment variables for Orbitrace credentials.
+Each project has two keys. The API key authenticates servers: keep it only in backend environments such as servers, workers, functions, and CI jobs, and never in `VITE_`, `NEXT_PUBLIC_` or other public frontend environment variables. The public key authenticates browsers: it may ship in bundles, and the API accepts it only from the project's allowed origins. Both keys can only create events.
 
-If this package is initialized in a browser runtime, it throws an error before sending events.
+The server entry throws if it is initialized in a browser, and the browser entry throws if it is given an API key.

package/dist/browser.cjs

@@ -0,0 +1,520 @@
+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"(exports2, module2) {
+    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 filterSensitive2(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) => filterSensitive2(item, ancestors)) : Object.fromEntries(
+        Object.entries(value).map(([key, item]) => [
+          key,
+          isSensitiveKey(key) ? FILTERED_VALUE : filterSensitive2(item, ancestors)
+        ])
+      );
+      ancestors.delete(value);
+      return filtered;
+    }
+    function truncate2(value, maxLength) {
+      return value.length > maxLength ? `${value.slice(0, maxLength)}...` : value;
+    }
+    function cleanUrl2(url) {
+      try {
+        const parsed = new URL(url);
+        return `${parsed.origin}${parsed.pathname}`;
+      } catch {
+        return String(url).split(/[?#]/)[0];
+      }
+    }
+    function pushBreadcrumb2(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: truncate2(String(message), MAX_BREADCRUMB_MESSAGE_LENGTH),
+          ...data !== void 0 && { data: filterSensitive2(data) }
+        });
+        if (breadcrumbs.length > MAX_BREADCRUMBS) {
+          breadcrumbs.shift();
+        }
+      } catch {
+      }
+    }
+    function httpBreadcrumb({ method, url, status, error, started }) {
+      const data = { method, url: cleanUrl2(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 recordFetch2({ 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 recordConsole2({ 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 Sender2 = 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);
+      }
+    };
+    module2.exports = {
+      MAX_BREADCRUMB_MESSAGE_LENGTH,
+      Sender: Sender2,
+      cleanUrl: cleanUrl2,
+      filterSensitive: filterSensitive2,
+      pushBreadcrumb: pushBreadcrumb2,
+      recordConsole: recordConsole2,
+      recordFetch: recordFetch2,
+      truncate: truncate2
+    };
+  }
+});
+
+// src/browser.js
+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;