reroute-js 0.26.0 → 0.27.0

package/telemetry/react.js

@@ -1,5 +1,5 @@
 /**
- * reroute-js v0.26.0
+ * reroute-js v0.27.0
  *
  * @license MIT
  * @copyright 2025 stewones <hi@stewan.io>
@@ -51,10 +51,29 @@ import {
   useState
 } from "react";
 import { jsx } from "react/jsx-runtime";
+function deserializeIgnoreRoutes(serialized) {
+  if (!(serialized && Array.isArray(serialized)))
+    return;
+  return serialized.map((pattern) => {
+    if (pattern?.type === "string") {
+      return pattern.value;
+    }
+    if (pattern?.type === "regex") {
+      return new RegExp(pattern.value, pattern.flags);
+    }
+    if (pattern?.type === "function") {
+      return new Function(`return ${pattern.value}`)();
+    }
+    return pattern;
+  });
+}
 function getBrowserTelemetryConfig() {
   if (typeof window !== "undefined") {
     const globalConfig = window.__REROUTE_TELEMETRY_BROWSER__;
     if (globalConfig) {
+      if (globalConfig.ignoreRoutes) {
+        globalConfig.ignoreRoutes = deserializeIgnoreRoutes(globalConfig.ignoreRoutes);
+      }
       return globalConfig;
     }
   }
@@ -78,10 +97,11 @@ function TelemetryProvider({
     enabled: enabled ?? globalConfig.enabled ?? false,
     serviceName: serviceName ?? globalConfig.serviceName ?? "reroute-app-browser",
     serviceVersion: serviceVersion ?? globalConfig.serviceVersion ?? "1.0.0",
-    otlpEndpoint: otlpEndpoint ?? globalConfig.otlpEndpoint ?? "/api/telemetry",
+    otlpEndpoint: otlpEndpoint ?? globalConfig.otlpEndpoint ?? "/__reroute/telemetry",
     apiKey: apiKey ?? globalConfig.apiKey,
     environment: environment ?? globalConfig.environment ?? "development",
-    enableConsoleCapture: enableConsoleCapture ?? globalConfig.enableConsoleCapture ?? true
+    enableConsoleCapture: enableConsoleCapture ?? globalConfig.enableConsoleCapture ?? true,
+    ignoreRoutes: globalConfig.ignoreRoutes
   }), [
     enabled,
     serviceName,
@@ -167,12 +187,97 @@ var init_api = __esm(() => {
   TelemetryContext = createContext(null);
 });
 
+// packages/telemetry/src/react/context.ts
+function setContext(attributes) {
+  contextAttributes = { ...contextAttributes, ...attributes };
+}
+function clearContext() {
+  contextAttributes = {};
+}
+function getContextAttr() {
+  return contextAttributes;
+}
+function getContextAttributesForTelemetry() {
+  const prefixed = {};
+  for (const [key, value] of Object.entries(contextAttributes)) {
+    prefixed[`context.${key}`] = value;
+  }
+  return prefixed;
+}
+var contextAttributes;
+var init_context = __esm(() => {
+  contextAttributes = {};
+});
+
 // packages/telemetry/src/react/telemetry.ts
+function addBreadcrumb(category, message, data) {
+  breadcrumbs.push({
+    timestamp: Date.now(),
+    category,
+    message,
+    data
+  });
+  if (breadcrumbs.length > MAX_BREADCRUMBS) {
+    breadcrumbs.shift();
+  }
+}
+function addNetworkRequest(request) {
+  networkRequests.push(request);
+  if (networkRequests.length > MAX_NETWORK_REQUESTS) {
+    networkRequests.shift();
+  }
+}
+async function setupTraceContextFromServer() {
+  try {
+    const injectedContext = window.__REROUTE_TRACE_CONTEXT__;
+    if (!injectedContext?.traceparent) {
+      console.log("[browser-telemetry] No server trace context found - spans will start new traces");
+      return;
+    }
+    const parts = injectedContext.traceparent.split("-");
+    if (parts.length >= 3) {
+      serverTraceContext = {
+        traceId: parts[1],
+        spanId: parts[2],
+        traceparent: injectedContext.traceparent,
+        tracestate: injectedContext.tracestate
+      };
+      console.log("[browser-telemetry] Server trace context stored for correlation:", injectedContext.traceparent);
+    }
+  } catch (error) {
+    console.error("[browser-telemetry] Failed to extract server trace context:", error);
+  }
+}
+function shouldIgnoreUrl(url, method = "GET") {
+  if (ignorePatterns.length === 0)
+    return false;
+  let pathname;
+  try {
+    pathname = new URL(url, window.location.origin).pathname;
+  } catch {
+    pathname = url;
+  }
+  return ignorePatterns.some((pattern) => {
+    if (typeof pattern === "string") {
+      return pathname.includes(pattern) || url.includes(pattern);
+    }
+    if (pattern instanceof RegExp) {
+      return pattern.test(pathname) || pattern.test(url);
+    }
+    if (typeof pattern === "function") {
+      return pattern(pathname, method);
+    }
+    return false;
+  });
+}
 async function initBrowserTelemetry(options = {}) {
   if (IS_SERVER2 || isInitialized) {
     return;
   }
   isInitialized = true;
+  if (options.ignoreRoutes) {
+    ignorePatterns = options.ignoreRoutes;
+  }
   try {
     const [
       { getWebAutoInstrumentations },
@@ -196,7 +301,7 @@ async function initBrowserTelemetry(options = {}) {
     const env = typeof import.meta !== "undefined" ? import.meta.env : undefined;
     const SERVICE_NAME = options.serviceName || "reroute-app-browser";
     const SERVICE_VERSION = options.serviceVersion || "1.0.0";
-    const OTLP_ENDPOINT = options.otlpEndpoint || "/api/telemetry";
+    const OTLP_ENDPOINT = options.otlpEndpoint || "/__reroute/telemetry";
     const ENVIRONMENT = options.environment || env?.MODE || "development";
     const ENABLE_CONSOLE_CAPTURE = options.enableConsoleCapture ?? true;
     console.log(`[browser-telemetry] Initializing with endpoint: ${OTLP_ENDPOINT}`);
@@ -213,7 +318,7 @@ async function initBrowserTelemetry(options = {}) {
       [ATTR_SERVICE_NAME]: SERVICE_NAME,
       [ATTR_SERVICE_VERSION]: SERVICE_VERSION,
       "deployment.environment": ENVIRONMENT,
-      "browser.user_agent": navigator.userAgent,
+      "browser.agent": navigator.userAgent,
       "browser.language": navigator.language,
       "browser.platform": navigator.platform,
       "screen.width": window.screen.width,
@@ -231,6 +336,7 @@ async function initBrowserTelemetry(options = {}) {
     tracerProvider.register({
       contextManager: new ZoneContextManager
     });
+    await setupTraceContextFromServer();
     registerInstrumentations({
       instrumentations: [
         getWebAutoInstrumentations({
@@ -243,12 +349,54 @@ async function initBrowserTelemetry(options = {}) {
           "@opentelemetry/instrumentation-fetch": {
             enabled: true,
             propagateTraceHeaderCorsUrls: [/.*/],
-            clearTimingResources: true
+            clearTimingResources: true,
+            ignoreUrls: ignorePatterns.map((pattern) => {
+              if (typeof pattern === "string") {
+                return new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+              }
+              if (pattern instanceof RegExp) {
+                return pattern;
+              }
+              return /.^/;
+            }),
+            applyCustomAttributesOnSpan: (span, request) => {
+              const url = request.url || "";
+              const method = request.method || "GET";
+              for (const pattern of ignorePatterns) {
+                if (typeof pattern === "function") {
+                  if (shouldIgnoreUrl(url, method)) {
+                    span.end();
+                    return;
+                  }
+                }
+              }
+            }
           },
           "@opentelemetry/instrumentation-xml-http-request": {
             enabled: true,
             propagateTraceHeaderCorsUrls: [/.*/],
-            clearTimingResources: true
+            clearTimingResources: true,
+            ignoreUrls: ignorePatterns.map((pattern) => {
+              if (typeof pattern === "string") {
+                return new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+              }
+              if (pattern instanceof RegExp) {
+                return pattern;
+              }
+              return /.^/;
+            }),
+            applyCustomAttributesOnSpan: (span, request) => {
+              const url = request.url || "";
+              const method = request.method || "GET";
+              for (const pattern of ignorePatterns) {
+                if (typeof pattern === "function") {
+                  if (shouldIgnoreUrl(url, method)) {
+                    span.end();
+                    return;
+                  }
+                }
+              }
+            }
           }
         })
       ]
@@ -257,22 +405,246 @@ async function initBrowserTelemetry(options = {}) {
     if (ENABLE_CONSOLE_CAPTURE) {
       setupConsoleCapture().catch((err) => console.error("[browser-telemetry] Console capture setup failed:", err));
     }
+    setupBreadcrumbTracking();
+    setupNetworkTracking();
     console.log("[browser-telemetry] Initialized successfully");
   } catch (error) {
     console.error("[browser-telemetry] Failed to initialize:", error);
     isInitialized = false;
   }
 }
+function setupBreadcrumbTracking() {
+  if (IS_SERVER2)
+    return;
+  document.addEventListener("click", (event) => {
+    const target = event.target;
+    const tagName = target.tagName.toLowerCase();
+    const id = target.id ? `#${target.id}` : "";
+    const classes = target.className ? `.${target.className.split(" ").join(".")}` : "";
+    const text = target.textContent?.substring(0, 50) || "";
+    addBreadcrumb("ui.click", `Clicked ${tagName}${id}${classes}`, {
+      tag: tagName,
+      id: target.id,
+      text,
+      x: event.clientX,
+      y: event.clientY
+    });
+  }, { capture: true, passive: true });
+  const originalPushState = history.pushState;
+  const originalReplaceState = history.replaceState;
+  history.pushState = function(...args) {
+    addBreadcrumb("navigation", `Navigated to ${args[2]}`, {
+      url: String(args[2]),
+      type: "pushState"
+    });
+    return originalPushState.apply(this, args);
+  };
+  history.replaceState = function(...args) {
+    addBreadcrumb("navigation", `Replaced state: ${args[2]}`, {
+      url: String(args[2]),
+      type: "replaceState"
+    });
+    return originalReplaceState.apply(this, args);
+  };
+  window.addEventListener("popstate", () => {
+    addBreadcrumb("navigation", `Navigated to ${window.location.pathname}`, {
+      url: window.location.href,
+      type: "popstate"
+    });
+  });
+  document.addEventListener("submit", (event) => {
+    const form = event.target;
+    addBreadcrumb("ui.submit", `Form submitted: ${form.action || "unknown"}`, {
+      action: form.action,
+      method: form.method,
+      id: form.id
+    });
+  }, { capture: true, passive: true });
+  document.addEventListener("focus", (event) => {
+    const target = event.target;
+    if (target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.tagName === "SELECT") {
+      const input = target;
+      addBreadcrumb("ui.focus", `Focused ${input.type || input.tagName.toLowerCase()}`, {
+        tag: input.tagName.toLowerCase(),
+        type: input.type,
+        name: input.name,
+        id: input.id
+      });
+    }
+  }, { capture: true, passive: true });
+  console.log("[browser-telemetry] Breadcrumb tracking enabled");
+}
+function setupNetworkTracking() {
+  if (IS_SERVER2)
+    return;
+  const originalFetch = window.fetch;
+  window.fetch = async function(input, init) {
+    const startTime = Date.now();
+    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const method = init?.method || "GET";
+    const requestInfo = {
+      timestamp: startTime,
+      url,
+      method
+    };
+    try {
+      const response = await originalFetch.call(globalThis, input, init);
+      requestInfo.status = response.status;
+      requestInfo.duration = Date.now() - startTime;
+      requestInfo.error = response.status >= 400;
+      if (!shouldIgnoreUrl(url, method)) {
+        addNetworkRequest(requestInfo);
+        addBreadcrumb("http", `${method} ${url} → ${response.status}`, {
+          method,
+          url,
+          status: response.status,
+          duration: requestInfo.duration
+        });
+      }
+      return response;
+    } catch (error) {
+      requestInfo.duration = Date.now() - startTime;
+      requestInfo.error = true;
+      if (!shouldIgnoreUrl(url, method)) {
+        addNetworkRequest(requestInfo);
+        addBreadcrumb("http", `${method} ${url} → error`, {
+          method,
+          url,
+          error: error instanceof Error ? error.message : String(error),
+          duration: requestInfo.duration
+        });
+      }
+      throw error;
+    }
+  };
+  const originalXHROpen = XMLHttpRequest.prototype.open;
+  const originalXHRSend = XMLHttpRequest.prototype.send;
+  XMLHttpRequest.prototype.open = function(method, url, _async, _username, _password) {
+    this._telemetry = {
+      method,
+      url: String(url),
+      startTime: Date.now()
+    };
+    return originalXHROpen.apply(this);
+  };
+  XMLHttpRequest.prototype.send = function(body) {
+    const telemetry = this._telemetry;
+    if (telemetry) {
+      this.addEventListener("loadend", () => {
+        const duration = Date.now() - telemetry.startTime;
+        const requestInfo = {
+          timestamp: telemetry.startTime,
+          url: telemetry.url,
+          method: telemetry.method,
+          status: this.status,
+          duration,
+          error: this.status >= 400 || this.status === 0
+        };
+        if (!shouldIgnoreUrl(telemetry.url, telemetry.method)) {
+          addNetworkRequest(requestInfo);
+          addBreadcrumb("http", `${telemetry.method} ${telemetry.url} → ${this.status}`, {
+            method: telemetry.method,
+            url: telemetry.url,
+            status: this.status,
+            duration
+          });
+        }
+      });
+    }
+    return originalXHRSend.call(this, body);
+  };
+  console.log("[browser-telemetry] Network tracking enabled");
+}
+function getPerformanceMetrics() {
+  if (IS_SERVER2)
+    return {};
+  const metrics = {};
+  const memory = performance.memory;
+  if (memory) {
+    metrics["perf.memory.heap"] = memory.usedJSHeapSize;
+    metrics["perf.memory.total"] = memory.totalJSHeapSize;
+    metrics["perf.memory.limit"] = memory.jsHeapSizeLimit;
+    metrics["perf.memory.usage"] = Math.round(memory.usedJSHeapSize / memory.jsHeapSizeLimit * 100);
+  }
+  const navTiming = performance.timing;
+  if (navTiming) {
+    metrics["perf.timing"] = Date.now() - navTiming.navigationStart;
+  }
+  const connection = navigator.connection;
+  if (connection) {
+    metrics["perf.connection.type"] = connection.effectiveType;
+    metrics["perf.connection.downlink"] = connection.downlink;
+    metrics["perf.connection.rtt"] = connection.rtt;
+    metrics["perf.connection.save.data"] = connection.saveData;
+  }
+  metrics["perf.hardware.concurrency"] = navigator.hardwareConcurrency;
+  metrics["perf.device.memory"] = navigator.deviceMemory;
+  metrics["perf.viewport.width"] = window.innerWidth;
+  metrics["perf.viewport.height"] = window.innerHeight;
+  return metrics;
+}
+function getErrorContext() {
+  const context = {};
+  if (breadcrumbs.length > 0) {
+    context["context.journey"] = JSON.stringify(breadcrumbs);
+    context["context.journey.count"] = breadcrumbs.length;
+    context["context.last.action"] = breadcrumbs[breadcrumbs.length - 1]?.message;
+  }
+  if (networkRequests.length > 0) {
+    context["context.network.requests"] = JSON.stringify(networkRequests);
+    context["context.network.requests.count"] = networkRequests.length;
+    const failedRequests = networkRequests.filter((r) => r.error);
+    if (failedRequests.length > 0) {
+      context["context.network.failed.count"] = failedRequests.length;
+      context["context.network.failed.last"] = failedRequests[failedRequests.length - 1]?.url;
+    }
+  }
+  const perfMetrics = getPerformanceMetrics();
+  Object.assign(context, perfMetrics);
+  const sessionAttrs = getContextAttributesForTelemetry();
+  Object.assign(context, sessionAttrs);
+  return context;
+}
 async function setupErrorHandlers() {
   const { trace, SpanStatusCode } = await import("@opentelemetry/api");
   const tracer = trace.getTracer("error-handler");
-  window.addEventListener("error", (event) => {
+  window.addEventListener("error", async (event) => {
     try {
+      const links = [];
+      if (serverTraceContext) {
+        links.push({
+          context: {
+            traceId: serverTraceContext.traceId,
+            spanId: serverTraceContext.spanId,
+            traceFlags: 1
+          },
+          attributes: {
+            "link.type": "server_request"
+          }
+        });
+      }
       const span = tracer.startSpan("browser.error.uncaught", {
-        startTime: Date.now()
+        startTime: Date.now(),
+        links
       });
       const stackTrace = event.error?.stack || "";
       const errorMessage = event.message || event.error?.message || "Unknown error";
+      let mappedStack = stackTrace;
+      if (stackTrace) {
+        try {
+          const response = await fetch("/__reroute/telemetry/inspect", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ stack: stackTrace })
+          });
+          if (response.ok) {
+            const result = await response.json();
+            if (result.mapped) {
+              mappedStack = result.mapped;
+            }
+          }
+        } catch {}
+      }
       span.setStatus({
         code: SpanStatusCode.ERROR,
         message: errorMessage
@@ -282,20 +654,31 @@ async function setupErrorHandlers() {
         "error.type": event.error?.name || "UncaughtError",
         "error.message": errorMessage,
         "error.stack": stackTrace,
+        ...mappedStack !== stackTrace ? {
+          "error.stack.decoded": mappedStack
+        } : {},
         "error.filename": event.filename || "",
         "error.lineno": event.lineno || 0,
         "error.colno": event.colno || 0,
         "browser.url": window.location.href,
         "browser.pathname": window.location.pathname,
-        "browser.user_agent": navigator.userAgent,
-        "browser.timestamp": new Date().toISOString()
+        "browser.agent": navigator.userAgent,
+        "browser.timestamp": new Date().toISOString(),
+        ...serverTraceContext ? {
+          "server.trace_id": serverTraceContext.traceId,
+          "server.span_id": serverTraceContext.spanId
+        } : {},
+        ...getErrorContext()
       });
       if (event.error) {
-        span.recordException(event.error);
+        const mappedError = new Error(event.error.message);
+        mappedError.name = event.error.name;
+        mappedError.stack = mappedStack;
+        span.recordException(mappedError);
         span.addEvent("exception", {
           "exception.type": event.error.name,
           "exception.message": event.error.message,
-          "exception.stacktrace": stackTrace,
+          "exception.stacktrace": mappedStack,
           "exception.escaped": "false"
         });
       }
@@ -305,15 +688,45 @@ async function setupErrorHandlers() {
       console.error("[browser-telemetry] Error tracking failed:", telemetryError);
     }
   });
-  window.addEventListener("unhandledrejection", (event) => {
+  window.addEventListener("unhandledrejection", async (event) => {
     try {
+      const links = [];
+      if (serverTraceContext) {
+        links.push({
+          context: {
+            traceId: serverTraceContext.traceId,
+            spanId: serverTraceContext.spanId,
+            traceFlags: 1
+          },
+          attributes: {
+            "link.type": "server_request"
+          }
+        });
+      }
       const span = tracer.startSpan("browser.error.unhandled_rejection", {
-        startTime: Date.now()
+        startTime: Date.now(),
+        links
       });
       const isError = event.reason instanceof Error;
       const errorMessage = isError ? event.reason.message : String(event.reason);
       const errorStack = isError ? event.reason.stack || "" : "";
       const errorType = isError ? event.reason.name : "UnhandledRejection";
+      let mappedStack = errorStack;
+      if (errorStack) {
+        try {
+          const response = await fetch("/__reroute/telemetry/inspect", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ stack: errorStack })
+          });
+          if (response.ok) {
+            const result = await response.json();
+            if (result.mapped) {
+              mappedStack = result.mapped;
+            }
+          }
+        } catch {}
+      }
       span.setStatus({
         code: SpanStatusCode.ERROR,
         message: errorMessage
@@ -323,17 +736,28 @@ async function setupErrorHandlers() {
         "error.type": errorType,
         "error.message": errorMessage,
         "error.stack": errorStack,
+        ...mappedStack !== errorStack ? {
+          "error.stack.decoded": mappedStack
+        } : {},
         "browser.url": window.location.href,
         "browser.pathname": window.location.pathname,
-        "browser.user_agent": navigator.userAgent,
-        "browser.timestamp": new Date().toISOString()
+        "browser.agent": navigator.userAgent,
+        "browser.timestamp": new Date().toISOString(),
+        ...serverTraceContext ? {
+          "server.trace_id": serverTraceContext.traceId,
+          "server.span_id": serverTraceContext.spanId
+        } : {},
+        ...getErrorContext()
       });
       if (isError) {
-        span.recordException(event.reason);
+        const mappedError = new Error(event.reason.message);
+        mappedError.name = event.reason.name;
+        mappedError.stack = mappedStack;
+        span.recordException(mappedError);
         span.addEvent("exception", {
           "exception.type": event.reason.name,
           "exception.message": event.reason.message,
-          "exception.stacktrace": errorStack,
+          "exception.stacktrace": mappedStack,
           "exception.escaped": "false"
         });
       }
@@ -353,12 +777,29 @@ async function setupConsoleCapture() {
   }
   const wrappedError = (...args) => {
     try {
-      const span = tracer.startSpan("browser.console.error");
+      const links = [];
+      if (serverTraceContext) {
+        links.push({
+          context: {
+            traceId: serverTraceContext.traceId,
+            spanId: serverTraceContext.spanId,
+            traceFlags: 1
+          },
+          attributes: {
+            "link.type": "server_request"
+          }
+        });
+      }
+      const span = tracer.startSpan("browser.console.error", { links });
       span.setAttributes({
         "log.level": "error",
         "log.message": args.map(String).join(" "),
         "browser.url": window.location.href,
-        "browser.timestamp": new Date().toISOString()
+        "browser.timestamp": new Date().toISOString(),
+        ...serverTraceContext ? {
+          "server.trace_id": serverTraceContext.traceId,
+          "server.span_id": serverTraceContext.spanId
+        } : {}
       });
       span.end();
     } catch {}
@@ -382,11 +823,26 @@ function createSpan(name, attributes = {}) {
       globalThis.__OTEL_TRACE__ = trace;
     }
     const tracer = trace.getTracer("custom");
-    const span = tracer.startSpan(name);
+    const links = [];
+    if (serverTraceContext) {
+      links.push({
+        context: {
+          traceId: serverTraceContext.traceId,
+          spanId: serverTraceContext.spanId,
+          traceFlags: 1
+        },
+        attributes: {
+          "link.type": "server_request",
+          "link.traceparent": serverTraceContext.traceparent
+        }
+      });
+    }
+    const span = tracer.startSpan(name, { links });
     span.setAttributes({
       ...attributes,
       "browser.url": window.location.href,
-      "browser.pathname": window.location.pathname
+      "browser.pathname": window.location.pathname,
+      ...serverTraceContext ? { "server.trace_id": serverTraceContext.traceId } : {}
     });
     return span;
   } catch (error) {
@@ -410,15 +866,44 @@ function trackEvent(eventName, attributes = {}) {
     console.error("[browser-telemetry] Failed to track event:", error);
   }
 }
-function trackError(error, context = {}) {
+async function trackError(error, context = {}) {
   if (IS_SERVER2 || !isInitialized) {
     return;
   }
   try {
     const { trace, SpanStatusCode } = __require("@opentelemetry/api");
     const tracer = trace.getTracer("error-handler");
-    const span = tracer.startSpan("browser.error.tracked");
+    const links = [];
+    if (serverTraceContext) {
+      links.push({
+        context: {
+          traceId: serverTraceContext.traceId,
+          spanId: serverTraceContext.spanId,
+          traceFlags: 1
+        },
+        attributes: {
+          "link.type": "server_request"
+        }
+      });
+    }
+    const span = tracer.startSpan("browser.error.tracked", { links });
     const stackTrace = error.stack || "";
+    let mappedStack = stackTrace;
+    if (stackTrace) {
+      try {
+        const response = await fetch("/__reroute/telemetry/inspect", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ stack: stackTrace })
+        });
+        if (response.ok) {
+          const result = await response.json();
+          if (result.mapped) {
+            mappedStack = result.mapped;
+          }
+        }
+      } catch {}
+    }
     span.setStatus({
       code: SpanStatusCode.ERROR,
       message: error.message
@@ -428,16 +913,27 @@ function trackError(error, context = {}) {
       "error.type": error.name,
       "error.message": error.message,
       "error.stack": stackTrace,
+      ...mappedStack !== stackTrace ? {
+        "error.stack.decoded": mappedStack
+      } : {},
       ...context,
       "browser.url": window.location.href,
       "browser.pathname": window.location.pathname,
-      "browser.timestamp": new Date().toISOString()
+      "browser.timestamp": new Date().toISOString(),
+      ...serverTraceContext ? {
+        "server.trace_id": serverTraceContext.traceId,
+        "server.span_id": serverTraceContext.spanId
+      } : {},
+      ...getErrorContext()
     });
-    span.recordException(error);
+    const mappedError = new Error(error.message);
+    mappedError.name = error.name;
+    mappedError.stack = mappedStack;
+    span.recordException(mappedError);
     span.addEvent("exception", {
       "exception.type": error.name,
       "exception.message": error.message,
-      "exception.stacktrace": stackTrace,
+      "exception.stacktrace": mappedStack,
       "exception.escaped": "false"
     });
     span.end();
@@ -452,14 +948,19 @@ async function shutdownTelemetry() {
     console.log("[browser-telemetry] Shut down successfully");
   }
 }
-var IS_SERVER2, isInitialized = false, tracerProvider = null;
+var IS_SERVER2, isInitialized = false, tracerProvider = null, serverTraceContext = null, ignorePatterns, breadcrumbs, MAX_BREADCRUMBS = 20, networkRequests, MAX_NETWORK_REQUESTS = 15;
 var init_telemetry = __esm(() => {
+  init_context();
   IS_SERVER2 = typeof window === "undefined";
+  ignorePatterns = [];
+  breadcrumbs = [];
+  networkRequests = [];
 });
 
 // packages/telemetry/src/react/index.ts
 var init_react = __esm(() => {
   init_api();
+  init_context();
   init_telemetry();
 });
 
@@ -470,8 +971,12 @@ __export(exports_react, {
   trackEvent: () => trackEvent,
   trackError: () => trackError,
   shutdownTelemetry: () => shutdownTelemetry,
+  setContext: () => setContext,
   initBrowserTelemetry: () => initBrowserTelemetry,
+  getContextAttributesForTelemetry: () => getContextAttributesForTelemetry,
+  getContextAttr: () => getContextAttr,
   createSpan: () => createSpan,
+  clearContext: () => clearContext,
   TelemetryProvider: () => TelemetryProvider
 });
 var init_react2 = __esm(() => {
@@ -484,9 +989,13 @@ export {
   trackEvent,
   trackError,
   shutdownTelemetry,
+  setContext,
   initBrowserTelemetry,
+  getContextAttributesForTelemetry,
+  getContextAttr,
   createSpan,
+  clearContext,
   TelemetryProvider
 };
 
-//# debugId=EF6D54D3079D2BAE64756E2164756E21
+//# debugId=523E68D56D72B13164756E2164756E21