reroute-js 0.26.0 → 0.27.0

package/telemetry/server.js

@@ -1,5 +1,5 @@
 /**
- * reroute-js v0.26.0
+ * reroute-js v0.27.0
  *
  * @license MIT
  * @copyright 2025 stewones <hi@stewan.io>
@@ -8,9 +8,49 @@
  * Built with Bun <3
  */
 import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// packages/telemetry/src/server/context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+function setContext(attributes) {
+  const current = contextStorage.getStore() || {};
+  const updated = { ...current, ...attributes };
+  try {
+    if (contextStorage.getStore()) {}
+  } catch {}
+  globalContextAttributes = updated;
+}
+function clearContext() {
+  globalContextAttributes = {};
+}
+function getContextAttr() {
+  return contextStorage.getStore() || globalContextAttributes || {};
+}
+function getContextAttributesForTelemetry() {
+  const attrs = getContextAttr();
+  const prefixed = {};
+  for (const [key, value] of Object.entries(attrs)) {
+    prefixed[`context.${key}`] = value;
+  }
+  return prefixed;
+}
+var contextStorage, globalContextAttributes;
+var init_context = __esm(() => {
+  contextStorage = new AsyncLocalStorage;
+  globalContextAttributes = {};
+});
+
 // packages/telemetry/src/server/instrumentation.ts
 import { context, SpanStatusCode, trace } from "@opentelemetry/api";
 function isOtelAvailable() {
@@ -133,6 +173,45 @@ function withParentSpanSync(parentSpan, fn) {
   const ctx = trace.setSpan(context.active(), parentSpan);
   return context.with(ctx, fn);
 }
+function extractTraceContext(headers) {
+  if (!isOtelAvailable())
+    return;
+  try {
+    const { propagation } = __require("@opentelemetry/api");
+    const carrier = {};
+    if (headers instanceof Headers) {
+      carrier.traceparent = headers.get("traceparent") || undefined;
+      carrier.tracestate = headers.get("tracestate") || undefined;
+    } else {
+      carrier.traceparent = headers.traceparent;
+      carrier.tracestate = headers.tracestate;
+    }
+    if (!carrier.traceparent) {
+      return;
+    }
+    return propagation.extract(context.active(), carrier);
+  } catch (error) {
+    console.error("[telemetry] Failed to extract trace context:", error);
+    return;
+  }
+}
+function getTraceContextForInjection(span) {
+  if (!(isOtelAvailable() && span))
+    return;
+  try {
+    const { propagation } = __require("@opentelemetry/api");
+    const carrier = {};
+    const ctx = trace.setSpan(context.active(), span);
+    propagation.inject(ctx, carrier);
+    return {
+      traceparent: carrier.traceparent,
+      tracestate: carrier.tracestate
+    };
+  } catch (error) {
+    console.error("[telemetry] Failed to get trace context for injection:", error);
+    return;
+  }
+}
 var otelAvailable, noopSpan;
 var init_instrumentation = __esm(() => {
   noopSpan = new NoopSpan;
@@ -514,9 +593,154 @@ var init_core = __esm(() => {
   init_src();
 });
 
+// packages/telemetry/src/server/sourcemap.ts
+var exports_sourcemap = {};
+__export(exports_sourcemap, {
+  resolveStackTrace: () => resolveStackTrace,
+  formatStackFrames: () => formatStackFrames,
+  enhanceError: () => enhanceError,
+  clearSourceMapCache: () => clearSourceMapCache
+});
+import { promises as fs } from "node:fs";
+import { join as join2 } from "node:path";
+import { SourceMapConsumer } from "source-map";
+function parseStackFrame(line) {
+  const patterns = [
+    /^\s*at\s+(.+?)\s+\((.+?):(\d+):(\d+)\)/,
+    /^\s*at\s+(.+?):(\d+):(\d+)/,
+    /^(.+?)@(.+?):(\d+):(\d+)/
+  ];
+  for (const pattern of patterns) {
+    const match = line.match(pattern);
+    if (match) {
+      if (match.length === 5 && match[2]) {
+        return {
+          raw: line,
+          functionName: match[1].trim(),
+          fileName: match[2],
+          lineNumber: Number.parseInt(match[3], 10),
+          columnNumber: Number.parseInt(match[4], 10)
+        };
+      }
+      if (match.length === 4 && match[1]) {
+        const hasAt = line.includes("@");
+        return {
+          raw: line,
+          functionName: hasAt ? match[1] : undefined,
+          fileName: hasAt ? match[2] : match[1],
+          lineNumber: Number.parseInt(hasAt ? match[3] : match[2], 10),
+          columnNumber: Number.parseInt(hasAt ? match[4] : match[3], 10)
+        };
+      }
+    }
+  }
+  return { raw: line };
+}
+async function loadSourceMap(fileName, rerouteDir) {
+  if (sourcemapCache.has(fileName)) {
+    return sourcemapCache.get(fileName) || null;
+  }
+  try {
+    const possiblePaths = [];
+    if (rerouteDir) {
+      const baseName = fileName.split("/").pop() || fileName;
+      possiblePaths.push(join2(rerouteDir, "bundles", `${baseName}.map`));
+    }
+    possiblePaths.push(`${fileName}.map`);
+    for (const mapPath of possiblePaths) {
+      try {
+        const mapContent = await fs.readFile(mapPath, "utf-8");
+        const consumer = await new SourceMapConsumer(mapContent);
+        sourcemapCache.set(fileName, consumer);
+        return consumer;
+      } catch {}
+    }
+    return null;
+  } catch (error) {
+    console.error(`[sourcemap] Failed to load sourcemap for ${fileName}:`, error);
+    return null;
+  }
+}
+function mapPosition(consumer, line, column) {
+  const pos = consumer.originalPositionFor({ line, column });
+  return {
+    source: pos.source,
+    line: pos.line,
+    column: pos.column,
+    name: pos.name
+  };
+}
+async function resolveStackTrace(stack, options = {}) {
+  const lines = stack.split(`
+`);
+  const frames = [];
+  for (const line of lines) {
+    const frame = parseStackFrame(line);
+    if (frame?.fileName && frame.lineNumber && frame.columnNumber) {
+      try {
+        const consumer = await loadSourceMap(frame.fileName, options.rerouteDir);
+        if (consumer) {
+          frame.mapped = mapPosition(consumer, frame.lineNumber, frame.columnNumber);
+        }
+      } catch (_error) {}
+    }
+    frames.push(frame);
+  }
+  const mappedLines = frames.map((frame) => {
+    if (frame.mapped?.source && frame.mapped.line !== null) {
+      const location = `${frame.mapped.source}:${frame.mapped.line}:${frame.mapped.column ?? 0}`;
+      if (frame.mapped.name || frame.functionName) {
+        return `    at ${frame.mapped.name || frame.functionName} (${location})`;
+      }
+      return `    at ${location}`;
+    }
+    return frame.raw;
+  });
+  return {
+    original: stack,
+    frames,
+    mapped: mappedLines.join(`
+`)
+  };
+}
+async function enhanceError(error, options = {}) {
+  if (!error.stack)
+    return error;
+  try {
+    const result = await resolveStackTrace(error.stack, options);
+    error.sourceMappedStack = result.mapped;
+    error.stackFrames = result.frames;
+  } catch {}
+  return error;
+}
+function clearSourceMapCache() {
+  for (const consumer of sourcemapCache.values()) {
+    consumer.destroy();
+  }
+  sourcemapCache.clear();
+}
+function formatStackFrames(frames) {
+  return frames.map((frame) => {
+    if (frame.mapped?.source && frame.mapped.line !== null) {
+      const location = `${frame.mapped.source}:${frame.mapped.line}:${frame.mapped.column ?? 0}`;
+      if (frame.mapped.name || frame.functionName) {
+        return `  at ${frame.mapped.name || frame.functionName} (${location})`;
+      }
+      return `  at ${location}`;
+    }
+    return frame.raw;
+  }).join(`
+`);
+}
+var sourcemapCache;
+var init_sourcemap = __esm(() => {
+  sourcemapCache = new Map;
+});
+
 // packages/telemetry/src/server/plugin.ts
 import os from "node:os";
 import {
+  context as context2,
   metrics,
   SpanStatusCode as SpanStatusCode2,
   trace as trace2
@@ -600,10 +824,10 @@ function telemetry(options = {}) {
     const OTLP_ENDPOINT = merged.otlpEndpoint || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318";
     const METRICS_INTERVAL = merged.metricsInterval ?? 5000;
     const proxyConfig = merged.proxy;
-    const ENABLE_PROXY = typeof proxyConfig === "boolean" ? proxyConfig : proxyConfig?.enabled ?? !!proxyConfig;
-    const PROXY_PATHNAME = typeof proxyConfig === "object" ? proxyConfig.pathname ?? "/api/telemetry" : "/api/telemetry";
-    const PROXY_VERBOSE = typeof proxyConfig === "object" ? proxyConfig.verbose ?? false : false;
-    const PROXY_HANDLER = typeof proxyConfig === "object" ? proxyConfig.handler : undefined;
+    const ENABLE_PROXY = proxyConfig?.enabled ?? !!proxyConfig;
+    const PROXY_PATHNAME = proxyConfig?.pathname ?? "/__reroute/telemetry";
+    const PROXY_VERBOSE = proxyConfig?.verbose ?? false;
+    const PROXY_HANDLER = proxyConfig?.handler;
     const ENABLE_TRACES = merged.enableTraces ?? true;
     const ENABLE_METRICS = merged.enableMetrics ?? true;
     const ENABLE_LOGS = merged.enableLogs ?? true;
@@ -817,19 +1041,27 @@ function telemetry(options = {}) {
           store.shouldIgnoreTelemetry = true;
         }
       }
+      const incomingContext = extractTraceContext(request.headers);
       if (tracer && !store.shouldIgnoreTelemetry) {
         try {
-          const span = tracer.startSpan(`${method} ${route}`, {
-            attributes: {
-              "http.request.method": method,
-              "http.route": route,
-              "url.full": request.url,
-              "url.scheme": url.protocol.replace(":", ""),
-              "server.address": url.host,
-              "service.name": SERVICE_NAME,
-              ...CUSTOM_ATTRIBUTES
-            }
-          });
+          const createSpan = () => {
+            return tracer.startSpan(`${method} ${route}`, {
+              attributes: {
+                "http.request.method": method,
+                "http.route": route,
+                "url.full": request.url,
+                "url.scheme": url.protocol.replace(":", ""),
+                "server.address": url.host,
+                "service.name": SERVICE_NAME,
+                ...CUSTOM_ATTRIBUTES
+              }
+            });
+          };
+          const span = incomingContext ? context2.with(incomingContext, createSpan) : createSpan();
+          const sessionAttrs = getContextAttributesForTelemetry();
+          if (Object.keys(sessionAttrs).length > 0) {
+            span.setAttributes(sessionAttrs);
+          }
           store.telemetrySpan = span;
         } catch (error) {
           console.error("[telemetry] Failed to create span:", error);
@@ -883,7 +1115,7 @@ function telemetry(options = {}) {
       } catch (error) {
         console.error("[telemetry] Failed to increment request counter:", error);
       }
-    }).onError(({ error, request, set, store }) => {
+    }).onError(async ({ error, request, set, store }) => {
       const errorDetails = getErrorDetails(error);
       const duration = Date.now() - (store.startTime || Date.now());
       const url = new URL(request.url);
@@ -897,24 +1129,38 @@ function telemetry(options = {}) {
           const span = store.telemetrySpan;
           if (span) {
             const errorObj = error instanceof Error ? error : new Error(errorDetails.message);
+            const rerouteDir = ".reroute";
+            if (rerouteDir && errorObj.stack) {
+              try {
+                await enhanceError(errorObj, { rerouteDir });
+              } catch (smError) {
+                console.error("[telemetry] Sourcemap enhancement failed:", smError);
+              }
+            }
             span.recordException(errorObj);
             span.setStatus({
               code: SpanStatusCode2.ERROR,
               message: `${errorDetails.name}: ${errorDetails.message}`
             });
+            const enhancedError = errorObj;
+            const stackToUse = enhancedError.sourceMappedStack || errorDetails.stack;
             span.setAttributes({
               error: true,
               "error.type": errorDetails.name,
               "error.message": errorDetails.message,
               "error.stack": errorDetails.stack,
+              ...enhancedError.sourceMappedStack ? {
+                "error.stack.decoded": enhancedError.sourceMappedStack
+              } : {},
               "http.response.status_code": typeof set.status === "number" ? set.status : 500,
               "http.duration_ms": duration,
-              ...CUSTOM_ATTRIBUTES
+              ...CUSTOM_ATTRIBUTES,
+              ...getContextAttributesForTelemetry()
             });
             span.addEvent("exception", {
               "exception.type": errorDetails.name,
               "exception.message": errorDetails.message,
-              "exception.stacktrace": errorDetails.stack,
+              "exception.stacktrace": stackToUse,
               "exception.escaped": "false"
             });
             span.end();
@@ -1029,6 +1275,29 @@ function telemetry(options = {}) {
         console.error("[telemetry] Failed to record request duration:", metricsError);
       }
     });
+    if (merged.sourcemaps?.enabled !== false) {
+      const rerouteDir = ".reroute";
+      app.post("/__reroute/telemetry/inspect", async ({ body }) => {
+        try {
+          const { stack } = body;
+          if (!stack) {
+            return { error: "Missing stack trace" };
+          }
+          const { resolveStackTrace: resolveStackTrace2 } = await Promise.resolve().then(() => (init_sourcemap(), exports_sourcemap));
+          const result = await resolveStackTrace2(stack, { rerouteDir });
+          return {
+            original: result.original,
+            mapped: result.mapped,
+            frames: result.frames
+          };
+        } catch (error) {
+          console.error("[telemetry] Error inspection failed:", error);
+          return {
+            error: error instanceof Error ? error.message : "Unknown error"
+          };
+        }
+      });
+    }
     if (ENABLE_PROXY) {
       const API_KEY = merged.apiKey || process.env.SIGNOZ_API_KEY;
       const handleProxy = async (endpoint, requestBody) => {
@@ -1107,12 +1376,17 @@ function telemetry(options = {}) {
 }
 var init_plugin = __esm(() => {
   init_core();
+  init_context();
+  init_instrumentation();
+  init_sourcemap();
 });
 
 // packages/telemetry/src/server/index.ts
 var init_server = __esm(() => {
+  init_context();
   init_instrumentation();
   init_plugin();
+  init_sourcemap();
 });
 
 // packages/telemetry/server.ts
@@ -1128,7 +1402,17 @@ export {
   withParentSpan,
   telemetry,
   setSpanAttributes,
+  setContext,
+  resolveStackTrace,
+  getTraceContextForInjection,
+  getContextAttributesForTelemetry,
+  getContextAttr,
+  formatStackFrames,
+  extractTraceContext,
+  enhanceError,
+  clearSourceMapCache,
+  clearContext,
   addSpanEvent
 };
 
-//# debugId=B91F92BF15BBA06264756E2164756E21
+//# debugId=428DDF76947758DA64756E2164756E21