reroute-js 0.25.2 → 0.26.0

package/telemetry/server.js

@@ -0,0 +1,1134 @@
+/**
+ * reroute-js v0.26.0
+ *
+ * @license MIT
+ * @copyright 2025 stewones <hi@stewan.io>
+ * @see https://github.com/stewones/reroute
+ *
+ * Built with Bun <3
+ */
+import { createRequire } from "node:module";
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/telemetry/src/server/instrumentation.ts
+import { context, SpanStatusCode, trace } from "@opentelemetry/api";
+function isOtelAvailable() {
+  if (otelAvailable !== undefined)
+    return otelAvailable;
+  try {
+    __require("@opentelemetry/api");
+    otelAvailable = true;
+    return true;
+  } catch {
+    otelAvailable = false;
+    return false;
+  }
+}
+
+class NoopSpan {
+  spanContext() {
+    return {
+      traceId: "",
+      spanId: "",
+      traceFlags: 0
+    };
+  }
+  setAttribute() {
+    return this;
+  }
+  setAttributes() {
+    return this;
+  }
+  addEvent() {
+    return this;
+  }
+  addLink() {
+    return this;
+  }
+  addLinks() {
+    return this;
+  }
+  setStatus() {
+    return this;
+  }
+  updateName() {
+    return this;
+  }
+  end() {}
+  isRecording() {
+    return false;
+  }
+  recordException() {}
+}
+async function withSpan(name, fn, attributes) {
+  if (!isOtelAvailable()) {
+    return fn(noopSpan);
+  }
+  const tracer = trace.getTracer("reroute");
+  return tracer.startActiveSpan(name, { attributes }, async (span) => {
+    try {
+      const result = await fn(span);
+      span.end();
+      return result;
+    } catch (error) {
+      span.recordException(error);
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      span.end();
+      throw error;
+    }
+  });
+}
+function withSpanSync(name, fn, attributes) {
+  if (!isOtelAvailable()) {
+    return fn(noopSpan);
+  }
+  const tracer = trace.getTracer("reroute");
+  return tracer.startActiveSpan(name, { attributes }, (span) => {
+    try {
+      const result = fn(span);
+      span.end();
+      return result;
+    } catch (error) {
+      span.recordException(error);
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      span.end();
+      throw error;
+    }
+  });
+}
+function setSpanAttributes(attributes) {
+  if (!isOtelAvailable())
+    return;
+  const span = trace.getActiveSpan();
+  if (span) {
+    span.setAttributes(attributes);
+  }
+}
+function addSpanEvent(name, attributes) {
+  if (!isOtelAvailable())
+    return;
+  const span = trace.getActiveSpan();
+  if (span) {
+    span.addEvent(name, attributes);
+  }
+}
+async function withParentSpan(parentSpan, fn) {
+  if (!(isOtelAvailable() && parentSpan)) {
+    return fn();
+  }
+  const ctx = trace.setSpan(context.active(), parentSpan);
+  return context.with(ctx, fn);
+}
+function withParentSpanSync(parentSpan, fn) {
+  if (!(isOtelAvailable() && parentSpan)) {
+    return fn();
+  }
+  const ctx = trace.setSpan(context.active(), parentSpan);
+  return context.with(ctx, fn);
+}
+var otelAvailable, noopSpan;
+var init_instrumentation = __esm(() => {
+  noopSpan = new NoopSpan;
+});
+// packages/core/src/bundler/index.ts
+var init_bundler = () => {};
+
+// packages/core/src/config.ts
+import { pathToFileURL } from "node:url";
+async function loadConfig(cwd) {
+  const bundledConfig = globalThis.__REROUTE_CONFIG__;
+  if (bundledConfig) {
+    return bundledConfig;
+  }
+  const configPath = `${cwd}/reroute.config.ts`;
+  const configFile = Bun.file(configPath);
+  if (!await configFile.exists()) {
+    return {};
+  }
+  try {
+    const mod = await import(`${pathToFileURL(configPath).href}?t=${Date.now()}`);
+    return mod.default || mod;
+  } catch (error) {
+    console.warn("[reroute] Failed to load reroute.config.ts:", error);
+    return {};
+  }
+}
+var init_config = () => {};
+// packages/core/src/content/discovery.ts
+var init_discovery = () => {};
+
+// packages/core/src/content/metadata.ts
+var init_metadata = () => {};
+
+// packages/core/src/content/index.ts
+var init_content = __esm(() => {
+  init_discovery();
+  init_metadata();
+});
+
+// packages/core/src/ssr/lib/cache.ts
+class SSRDataCache {
+  cache = new Map;
+  static cleanupInterval = null;
+  constructor() {
+    if (!SSRDataCache.cleanupInterval) {
+      SSRDataCache.cleanupInterval = setInterval(() => {
+        this.cleanup();
+      }, 60000);
+    }
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry)
+      return;
+    const age = Date.now() - entry.timestamp;
+    if (age > entry.maxAge) {
+      this.cache.delete(key);
+      return;
+    }
+    return entry.data;
+  }
+  set(key, data, maxAge) {
+    if (maxAge <= 0)
+      return;
+    this.cache.set(key, {
+      data,
+      timestamp: Date.now(),
+      maxAge
+    });
+  }
+  has(key) {
+    return this.get(key) !== undefined;
+  }
+  clear() {
+    this.cache.clear();
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (now - entry.timestamp > entry.maxAge) {
+        this.cache.delete(key);
+      }
+    }
+  }
+  stats() {
+    return {
+      size: this.cache.size,
+      keys: Array.from(this.cache.keys())
+    };
+  }
+  destroy() {
+    if (SSRDataCache.cleanupInterval) {
+      clearInterval(SSRDataCache.cleanupInterval);
+      SSRDataCache.cleanupInterval = null;
+    }
+    this.clear();
+  }
+}
+
+class LRUCache {
+  cache = new Map;
+  maxSize;
+  constructor(maxSize = 100) {
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    const value = this.cache.get(key);
+    if (value !== undefined) {
+      this.cache.delete(key);
+      this.cache.set(key, value);
+    }
+    return value;
+  }
+  set(key, value) {
+    this.cache.delete(key);
+    if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      this.cache.delete(firstKey);
+    }
+    this.cache.set(key, value);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+}
+var getGlobalCache = () => {
+  const g = globalThis;
+  if (!g.__REROUTE_SSR_CACHE__) {
+    g.__REROUTE_SSR_CACHE__ = new SSRDataCache;
+  }
+  return g.__REROUTE_SSR_CACHE__;
+}, getGlobalStatusCache = () => {
+  const g = globalThis;
+  if (!g.__REROUTE_STATUS_CACHE__) {
+    g.__REROUTE_STATUS_CACHE__ = new SSRDataCache;
+  }
+  return g.__REROUTE_STATUS_CACHE__;
+}, ssrCache, statusCache;
+var init_cache = __esm(() => {
+  ssrCache = getGlobalCache();
+  statusCache = getGlobalStatusCache();
+});
+
+// packages/core/src/ssr/lib/imports.ts
+var init_imports = () => {};
+
+// packages/core/src/ssr/lib/collections.ts
+var init_collections = __esm(() => {
+  init_imports();
+});
+// packages/core/src/ssr/lib/compression.ts
+var init_compression = () => {};
+
+// packages/core/src/ssr/lib/compute/content.ts
+var init_content2 = __esm(() => {
+  init_cache();
+  init_imports();
+});
+// packages/core/src/ssr/lib/compute/layouts.ts
+var init_layouts = __esm(() => {
+  init_cache();
+  init_imports();
+});
+
+// packages/core/src/ssr/lib/compute/routes.ts
+var init_routes = __esm(() => {
+  init_cache();
+  init_imports();
+});
+
+// packages/core/src/ssr/lib/compute/index.ts
+var init_compute = __esm(() => {
+  init_imports();
+  init_content2();
+  init_layouts();
+  init_routes();
+  init_content2();
+  init_layouts();
+  init_routes();
+});
+
+// packages/core/src/ssr/lib/modules.ts
+var init_modules = __esm(() => {
+  init_imports();
+});
+
+// packages/core/src/ssr/lib/seed.ts
+var init_seed = __esm(() => {
+  init_modules();
+});
+
+// packages/core/src/ssr/lib/data.ts
+var init_data = __esm(() => {
+  init_imports();
+  init_seed();
+});
+
+// packages/core/src/ssr/lib/html.ts
+var init_html = () => {};
+
+// packages/core/src/og/discovery.ts
+var init_discovery2 = () => {};
+
+// packages/core/src/og/meta.ts
+var init_meta = __esm(() => {
+  init_discovery2();
+});
+
+// packages/core/src/ssr/lib/metadata.ts
+var init_metadata2 = __esm(() => {
+  init_metadata();
+  init_meta();
+  init_imports();
+});
+
+// packages/core/src/ssr/lib/preload.ts
+var init_preload = __esm(() => {
+  init_imports();
+});
+// packages/core/src/ssr/lib/scripts/collections.ts
+var init_collections2 = () => {};
+
+// packages/core/src/ssr/lib/scripts/data.ts
+var init_data2 = () => {};
+
+// packages/core/src/ssr/lib/scripts/feeds.ts
+var init_feeds = () => {};
+
+// packages/core/src/ssr/lib/scripts/index.ts
+var init_scripts = __esm(() => {
+  init_collections2();
+  init_data2();
+  init_feeds();
+});
+
+// packages/core/src/ssr/lib/styles.ts
+var init_styles = () => {};
+
+// packages/core/src/ssr/lib/setup.ts
+var init_setup = __esm(() => {
+  init_server2();
+  init_collections();
+  init_compute();
+  init_metadata2();
+  init_preload();
+  init_scripts();
+  init_seed();
+  init_styles();
+});
+// packages/core/src/ssr/lib/index.ts
+var init_lib = __esm(() => {
+  init_data();
+  init_cache();
+  init_collections();
+  init_compression();
+  init_compute();
+  init_html();
+  init_imports();
+  init_metadata2();
+  init_modules();
+  init_preload();
+  init_scripts();
+  init_seed();
+  init_setup();
+  init_styles();
+});
+
+// packages/core/src/ssr/render.ts
+import dedent from "dedent";
+import { cloneElement } from "react";
+import { renderToString } from "react-dom/server";
+var init_render = __esm(() => {
+  init_server2();
+  init_config();
+  init_lib();
+  init_html();
+});
+// packages/core/src/llms/extractor.ts
+import { renderToStaticMarkup } from "react-dom/server";
+var init_extractor = __esm(() => {
+  init_render();
+});
+
+// packages/core/src/llms/full-generator.ts
+var init_full_generator = __esm(() => {
+  init_extractor();
+});
+
+// packages/core/src/llms/index-generator.ts
+var init_index_generator = __esm(() => {
+  init_extractor();
+});
+
+// packages/core/src/llms/index.ts
+var init_llms = __esm(() => {
+  init_extractor();
+  init_full_generator();
+  init_index_generator();
+});
+
+// packages/core/src/og/render.ts
+import { createElement } from "react";
+var init_render2 = () => {};
+
+// packages/core/src/og/index.ts
+var init_og = __esm(() => {
+  init_discovery2();
+  init_meta();
+  init_render2();
+});
+
+// packages/core/src/robots/discovery.ts
+var init_discovery3 = () => {};
+// packages/core/src/robots/policies.ts
+var init_policies = () => {};
+
+// packages/core/src/robots/index.ts
+var init_robots = __esm(() => {
+  init_discovery3();
+  init_policies();
+});
+
+// packages/core/src/rss/discovery.ts
+var init_discovery4 = () => {};
+// packages/core/src/rss/index.ts
+var init_rss = __esm(() => {
+  init_discovery4();
+});
+
+// packages/core/src/sitemap/discovery.ts
+var init_discovery5 = () => {};
+
+// packages/core/src/sitemap/generator.ts
+var init_generator = () => {};
+
+// packages/core/src/sitemap/index.ts
+var init_sitemap = __esm(() => {
+  init_discovery5();
+  init_generator();
+});
+
+// packages/core/src/ssr/stream.ts
+import { cloneElement as cloneElement2 } from "react";
+import { renderToReadableStream } from "react-dom/server";
+var init_stream = __esm(() => {
+  init_server2();
+  init_config();
+  init_lib();
+  init_html();
+  init_imports();
+});
+
+// packages/core/src/ssr/index.ts
+var init_ssr = __esm(() => {
+  init_lib();
+  init_render();
+  init_stream();
+});
+
+// packages/core/src/index.ts
+var init_src = __esm(() => {
+  init_bundler();
+  init_config();
+  init_content();
+  init_llms();
+  init_og();
+  init_robots();
+  init_rss();
+  init_sitemap();
+  init_ssr();
+});
+
+// packages/core/index.ts
+var init_core = __esm(() => {
+  init_src();
+});
+
+// packages/telemetry/src/server/plugin.ts
+import os from "node:os";
+import {
+  metrics,
+  SpanStatusCode as SpanStatusCode2,
+  trace as trace2
+} from "@opentelemetry/api";
+import { logs, SeverityNumber } from "@opentelemetry/api-logs";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-proto";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-proto";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import {
+  BatchLogRecordProcessor,
+  LoggerProvider
+} from "@opentelemetry/sdk-logs";
+import {
+  MeterProvider,
+  PeriodicExportingMetricReader
+} from "@opentelemetry/sdk-metrics";
+import {
+  BatchSpanProcessor,
+  NodeTracerProvider
+} from "@opentelemetry/sdk-trace-node";
+import {
+  ATTR_SERVICE_NAME,
+  ATTR_SERVICE_VERSION
+} from "@opentelemetry/semantic-conventions";
+import { ATTR_HOST_NAME } from "@opentelemetry/semantic-conventions/incubating";
+function getErrorDetails(error) {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack || ""
+    };
+  }
+  if (typeof error === "object" && error !== null) {
+    const err = error;
+    return {
+      name: String(err.name || err.code || "UnknownError"),
+      message: String(err.message || err.error || JSON.stringify(error)),
+      stack: String(err.stack || "")
+    };
+  }
+  return {
+    name: "UnknownError",
+    message: String(error),
+    stack: ""
+  };
+}
+function shouldIgnoreRoute(patterns, pathname, method) {
+  return patterns.some((pattern) => {
+    if (typeof pattern === "string") {
+      return pathname.includes(pattern);
+    }
+    if (pattern instanceof RegExp) {
+      return pattern.test(pathname);
+    }
+    if (typeof pattern === "function") {
+      return pattern(pathname, method);
+    }
+    return false;
+  });
+}
+function shouldSample(rate) {
+  return Math.random() < rate;
+}
+function telemetry(options = {}) {
+  return async (app) => {
+    const cwd = typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd() : "/";
+    const config2 = await loadConfig(cwd);
+    const merged = {
+      ...config2.telemetry,
+      ...options
+    };
+    const TELEMETRY_ENABLED = merged.enabled ?? false;
+    if (!TELEMETRY_ENABLED) {
+      console.log("[telemetry] Disabled - set enabled: true in config or options to enable");
+      return app;
+    }
+    const SERVICE_NAME = merged.serviceName || "reroute-app";
+    const SERVICE_VERSION = merged.serviceVersion || process.env.npm_package_version || "1.0.0";
+    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_TRACES = merged.enableTraces ?? true;
+    const ENABLE_METRICS = merged.enableMetrics ?? true;
+    const ENABLE_LOGS = merged.enableLogs ?? true;
+    const ENABLE_SYSTEM_METRICS = merged.enableSystemMetrics ?? true;
+    const SAMPLE_RATE = merged.sampleRate ?? 1;
+    const ERROR_SAMPLE_RATE = merged.errorSampleRate ?? 1;
+    const IGNORE_ROUTES = merged.ignoreRoutes || [];
+    const CAPTURE_HEADERS = merged.captureHeaders || [];
+    const CUSTOM_ATTRIBUTES = merged.customAttributes || {};
+    console.log(`[telemetry] Initializing with endpoint: ${OTLP_ENDPOINT}`);
+    console.log(`[telemetry] Features - Traces: ${ENABLE_TRACES}, Metrics: ${ENABLE_METRICS}, Logs: ${ENABLE_LOGS}`);
+    if (SAMPLE_RATE < 1) {
+      console.log(`[telemetry] Sampling - Requests: ${SAMPLE_RATE * 100}%, Errors: ${ERROR_SAMPLE_RATE * 100}%`);
+    }
+    if (ENABLE_PROXY) {
+      console.log(`[telemetry] Browser telemetry proxy enabled at ${PROXY_PATHNAME}/*`);
+    }
+    const otlpHeaders = {};
+    if (merged.apiKey || process.env.SIGNOZ_API_KEY) {
+      otlpHeaders.Authorization = `Bearer ${merged.apiKey || process.env.SIGNOZ_API_KEY}`;
+    }
+    const traceExporter = ENABLE_TRACES ? new OTLPTraceExporter({
+      url: `${OTLP_ENDPOINT}/v1/traces`,
+      headers: Object.keys(otlpHeaders).length > 0 ? otlpHeaders : undefined,
+      timeoutMillis: 5000
+    }) : null;
+    const logExporter = ENABLE_LOGS ? new OTLPLogExporter({
+      url: `${OTLP_ENDPOINT}/v1/logs`,
+      headers: Object.keys(otlpHeaders).length > 0 ? otlpHeaders : undefined,
+      timeoutMillis: 5000
+    }) : null;
+    const metricExporter = ENABLE_METRICS ? new OTLPMetricExporter({
+      url: `${OTLP_ENDPOINT}/v1/metrics`,
+      headers: Object.keys(otlpHeaders).length > 0 ? otlpHeaders : undefined,
+      timeoutMillis: 5000
+    }) : null;
+    const HOSTNAME = process.env.OTEL_RESOURCE_ATTRIBUTES?.match(/host\.name=([^,]+)/)?.[1] || process.env.HOSTNAME || os.hostname();
+    const resource = resourceFromAttributes({
+      [ATTR_SERVICE_NAME]: SERVICE_NAME,
+      [ATTR_SERVICE_VERSION]: SERVICE_VERSION,
+      [ATTR_HOST_NAME]: HOSTNAME
+    });
+    if (ENABLE_TRACES && traceExporter) {
+      try {
+        const tracerProvider = new NodeTracerProvider({
+          resource,
+          spanProcessors: [new BatchSpanProcessor(traceExporter)]
+        });
+        tracerProvider.register();
+      } catch (error) {
+        console.error("[telemetry] Failed to initialize tracer:", error);
+      }
+    }
+    let logger = null;
+    if (ENABLE_LOGS && logExporter) {
+      try {
+        const loggerProvider = new LoggerProvider({
+          resource,
+          processors: [new BatchLogRecordProcessor(logExporter)]
+        });
+        logs.setGlobalLoggerProvider(loggerProvider);
+        logger = loggerProvider.getLogger(SERVICE_NAME, SERVICE_VERSION);
+      } catch (error) {
+        console.error("[telemetry] Failed to initialize logger:", error);
+      }
+    }
+    let meter = null;
+    if (ENABLE_METRICS && metricExporter) {
+      try {
+        const meterProvider = new MeterProvider({
+          resource,
+          readers: [
+            new PeriodicExportingMetricReader({
+              exporter: metricExporter,
+              exportIntervalMillis: METRICS_INTERVAL
+            })
+          ]
+        });
+        metrics.setGlobalMeterProvider(meterProvider);
+        meter = meterProvider.getMeter(SERVICE_NAME, SERVICE_VERSION);
+      } catch (error) {
+        console.error("[telemetry] Failed to initialize meter:", error);
+      }
+    }
+    let httpRequestCounter = null;
+    let httpRequestDuration = null;
+    let httpErrorCounter = null;
+    let httpActiveRequests = null;
+    let activeConnections = null;
+    if (meter) {
+      try {
+        httpRequestCounter = meter.createCounter("http.server.request.count", {
+          description: "Total HTTP requests",
+          unit: "requests"
+        });
+        httpRequestDuration = meter.createHistogram("http.server.request.duration", {
+          description: "HTTP request duration",
+          unit: "milliseconds"
+        });
+        httpErrorCounter = meter.createCounter("http.server.error.count", {
+          description: "Total HTTP errors",
+          unit: "errors"
+        });
+        httpActiveRequests = meter.createUpDownCounter("http.server.active_requests", {
+          description: "Active HTTP requests",
+          unit: "requests"
+        });
+        activeConnections = meter.createUpDownCounter("app.connections.active", {
+          description: "Active connections",
+          unit: "connections"
+        });
+      } catch (error) {
+        console.error("[telemetry] Failed to create HTTP metrics:", error);
+      }
+    }
+    if (ENABLE_SYSTEM_METRICS && meter) {
+      try {
+        const memoryUsage = meter.createObservableGauge("app.memory.usage", {
+          description: "Process memory usage",
+          unit: "bytes"
+        });
+        memoryUsage.addCallback((result) => {
+          try {
+            const usage = process.memoryUsage();
+            result.observe(usage.heapUsed, {
+              type: "heap",
+              "host.name": HOSTNAME
+            });
+            result.observe(usage.rss, { type: "rss", "host.name": HOSTNAME });
+            result.observe(usage.external, {
+              type: "external",
+              "host.name": HOSTNAME
+            });
+          } catch (error) {
+            console.error("[telemetry] Memory usage callback failed:", error);
+          }
+        });
+        const systemCpuUsage = meter.createObservableGauge("system.cpu.utilization", {
+          description: "System CPU utilization",
+          unit: "1"
+        });
+        systemCpuUsage.addCallback((result) => {
+          try {
+            const cpus = os.cpus();
+            let totalIdle = 0;
+            let totalTick = 0;
+            cpus.forEach((cpu) => {
+              const times = cpu.times;
+              totalIdle += times.idle;
+              totalTick += times.user + times.nice + times.sys + times.idle + times.irq;
+            });
+            const usage = 1 - totalIdle / totalTick;
+            result.observe(usage, {
+              "service.name": SERVICE_NAME,
+              "host.name": HOSTNAME
+            });
+          } catch (error) {
+            console.error("[telemetry] CPU usage callback failed:", error);
+          }
+        });
+        const systemMemoryUsage = meter.createObservableGauge("system.memory.utilization", {
+          description: "System memory utilization",
+          unit: "1"
+        });
+        systemMemoryUsage.addCallback((result) => {
+          try {
+            const totalMem = os.totalmem();
+            const freeMem = os.freemem();
+            const usage = (totalMem - freeMem) / totalMem;
+            result.observe(usage, {
+              "service.name": SERVICE_NAME,
+              "host.name": HOSTNAME
+            });
+          } catch (error) {
+            console.error("[telemetry] System memory callback failed:", error);
+          }
+        });
+      } catch (error) {
+        console.error("[telemetry] Failed to create system metrics:", error);
+      }
+    }
+    const shutdown = async () => {
+      console.log("[telemetry] Shutting down...");
+      try {
+        await logs.disable();
+      } catch (error) {
+        console.error("[telemetry] Shutdown error:", error);
+      }
+    };
+    process.on("SIGTERM", async () => {
+      await shutdown();
+      process.exit(0);
+    });
+    let tracer = null;
+    if (ENABLE_TRACES && traceExporter) {
+      tracer = trace2.getTracer(SERVICE_NAME, SERVICE_VERSION);
+    }
+    app = app.onBeforeHandle(({ request, store }) => {
+      const startTime = Date.now();
+      const url = new URL(request.url);
+      const route = url.pathname;
+      const method = request.method;
+      store.startTime = startTime;
+      store.route = route;
+      const shouldIgnore = IGNORE_ROUTES.length > 0 && shouldIgnoreRoute(IGNORE_ROUTES, route, method);
+      store.shouldIgnoreTelemetry = shouldIgnore;
+      if (!shouldIgnore) {
+        const sampled = shouldSample(SAMPLE_RATE);
+        store.isSampled = sampled;
+        if (!sampled) {
+          store.shouldIgnoreTelemetry = true;
+        }
+      }
+      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
+            }
+          });
+          store.telemetrySpan = span;
+        } catch (error) {
+          console.error("[telemetry] Failed to create span:", error);
+        }
+      }
+      try {
+        activeConnections?.add(1);
+        httpActiveRequests?.add(1, {
+          "http.request.method": method,
+          route
+        });
+      } catch (error) {
+        console.error("[telemetry] Failed to track active requests:", error);
+      }
+      if (store.shouldIgnoreTelemetry) {
+        return;
+      }
+      const capturedHeaders = {};
+      for (const headerName of CAPTURE_HEADERS) {
+        const headerValue = request.headers.get(headerName);
+        if (headerValue) {
+          capturedHeaders[`http.request.header.${headerName}`] = headerValue;
+        }
+      }
+      const baseAttributes = {
+        "http.request.method": method,
+        "url.full": request.url,
+        "http.route": route,
+        "url.scheme": url.protocol.replace(":", ""),
+        "server.address": url.host,
+        "service.name": SERVICE_NAME,
+        ...CUSTOM_ATTRIBUTES,
+        ...capturedHeaders
+      };
+      try {
+        logger?.emit({
+          severityNumber: SeverityNumber.INFO,
+          severityText: "INFO",
+          body: `→ ${method} ${route}`,
+          attributes: baseAttributes
+        });
+      } catch (error) {
+        console.error("[telemetry] Failed to log incoming request:", error);
+      }
+      try {
+        httpRequestCounter?.add(1, {
+          "http.request.method": method,
+          "http.route": route,
+          "url.scheme": url.protocol.replace(":", "")
+        });
+      } catch (error) {
+        console.error("[telemetry] Failed to increment request counter:", error);
+      }
+    }).onError(({ error, request, set, store }) => {
+      const errorDetails = getErrorDetails(error);
+      const duration = Date.now() - (store.startTime || Date.now());
+      const url = new URL(request.url);
+      const route = url.pathname;
+      const method = request.method;
+      const shouldIgnore = IGNORE_ROUTES.length > 0 && shouldIgnoreRoute(IGNORE_ROUTES, route, method);
+      const errorSampled = shouldSample(ERROR_SAMPLE_RATE);
+      const skipTelemetry = shouldIgnore || !errorSampled;
+      if (!skipTelemetry) {
+        try {
+          const span = store.telemetrySpan;
+          if (span) {
+            const errorObj = error instanceof Error ? error : new Error(errorDetails.message);
+            span.recordException(errorObj);
+            span.setStatus({
+              code: SpanStatusCode2.ERROR,
+              message: `${errorDetails.name}: ${errorDetails.message}`
+            });
+            span.setAttributes({
+              error: true,
+              "error.type": errorDetails.name,
+              "error.message": errorDetails.message,
+              "error.stack": errorDetails.stack,
+              "http.response.status_code": typeof set.status === "number" ? set.status : 500,
+              "http.duration_ms": duration,
+              ...CUSTOM_ATTRIBUTES
+            });
+            span.addEvent("exception", {
+              "exception.type": errorDetails.name,
+              "exception.message": errorDetails.message,
+              "exception.stacktrace": errorDetails.stack,
+              "exception.escaped": "false"
+            });
+            span.end();
+          }
+        } catch (spanError) {
+          console.error("[telemetry] Failed to record exception in span:", spanError);
+        }
+        try {
+          logger?.emit({
+            severityNumber: SeverityNumber.ERROR,
+            severityText: "ERROR",
+            body: `${errorDetails.name}: ${errorDetails.message}`,
+            attributes: {
+              "error.type": errorDetails.name,
+              "error.message": errorDetails.message,
+              "error.stack": errorDetails.stack,
+              "http.request.method": method,
+              "url.full": request.url,
+              "http.response.status_code": typeof set.status === "number" ? set.status : 500,
+              "service.name": SERVICE_NAME,
+              ...CUSTOM_ATTRIBUTES
+            }
+          });
+        } catch (logError) {
+          console.error("[telemetry] Failed to log error:", logError);
+        }
+        try {
+          const statusCode = typeof set.status === "number" ? set.status : 500;
+          httpErrorCounter?.add(1, {
+            "http.request.method": method,
+            "http.response.status_code": statusCode,
+            "error.type": errorDetails.name
+          });
+          httpRequestDuration?.record(duration, {
+            "http.request.method": method,
+            "http.response.status_code": statusCode,
+            error: true
+          });
+        } catch (metricsError) {
+          console.error("[telemetry] Failed to record error metrics:", metricsError);
+        }
+      }
+    }).onAfterResponse(({ request, set, store }) => {
+      const url = new URL(request.url);
+      const pathname = url.pathname;
+      const method = request.method;
+      const statusCode = typeof set.status === "number" ? set.status : 200;
+      const duration = Date.now() - (store.startTime || Date.now());
+      const route = store.route || pathname;
+      try {
+        activeConnections?.add(-1);
+        httpActiveRequests?.add(-1, {
+          "http.request.method": method,
+          route
+        });
+      } catch (error) {
+        console.error("[telemetry] Failed to decrement active requests:", error);
+      }
+      const shouldIgnoreTelemetry = store.shouldIgnoreTelemetry;
+      if (shouldIgnoreTelemetry) {
+        return;
+      }
+      try {
+        const span = store.telemetrySpan;
+        if (span) {
+          span.setAttributes({
+            "http.response.status_code": statusCode,
+            "http.duration_ms": duration,
+            ...CUSTOM_ATTRIBUTES
+          });
+          if (statusCode >= 400) {
+            span.setStatus({
+              code: SpanStatusCode2.ERROR,
+              message: `HTTP ${statusCode}`
+            });
+            span.setAttribute("error", true);
+          }
+          span.end();
+        }
+      } catch (spanError) {
+        console.error("[telemetry] Failed to end span:", spanError);
+      }
+      try {
+        const isError = statusCode >= 400;
+        logger?.emit({
+          severityNumber: isError ? SeverityNumber.ERROR : SeverityNumber.INFO,
+          severityText: isError ? "ERROR" : "INFO",
+          body: `← ${method} ${route} → ${statusCode} (${duration}ms)`,
+          attributes: {
+            "http.request.method": method,
+            "url.full": request.url,
+            "http.route": route,
+            "http.response.status_code": statusCode,
+            "http.duration_ms": duration,
+            "url.scheme": url.protocol.replace(":", ""),
+            "server.address": url.host,
+            "service.name": SERVICE_NAME,
+            ...CUSTOM_ATTRIBUTES
+          }
+        });
+      } catch (logError) {
+        console.error("[telemetry] Failed to log response:", logError);
+      }
+      try {
+        httpRequestDuration?.record(duration, {
+          "http.request.method": method,
+          "http.route": route,
+          "http.response.status_code": statusCode,
+          "url.scheme": url.protocol.replace(":", "")
+        });
+      } catch (metricsError) {
+        console.error("[telemetry] Failed to record request duration:", metricsError);
+      }
+    });
+    if (ENABLE_PROXY) {
+      const API_KEY = merged.apiKey || process.env.SIGNOZ_API_KEY;
+      const handleProxy = async (endpoint, requestBody) => {
+        const headers = {
+          "Content-Type": "application/json"
+        };
+        if (API_KEY) {
+          headers.Authorization = `Bearer ${API_KEY}`;
+        }
+        if (PROXY_HANDLER) {
+          return await PROXY_HANDLER({
+            body: requestBody,
+            endpoint,
+            headers,
+            otlpEndpoint: OTLP_ENDPOINT
+          });
+        }
+        try {
+          const controller = new AbortController;
+          const timeoutId = setTimeout(() => controller.abort(), 5000);
+          const response = await fetch(`${OTLP_ENDPOINT}${endpoint}`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(requestBody),
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (PROXY_VERBOSE) {
+            console.log(`[telemetry-proxy]${endpoint} forwarded: ${response.status}`);
+          }
+          if (!response.ok && PROXY_VERBOSE) {
+            console.error(`[telemetry-proxy] OTLP error: ${response.status} ${response.statusText}`);
+          }
+          return { status: 200 };
+        } catch (error) {
+          if (PROXY_VERBOSE) {
+            console.error(`[telemetry-proxy] Failed to forward${endpoint}:`, error);
+          }
+          return { status: 200 };
+        }
+      };
+      app.post(`${PROXY_PATHNAME}/v1/traces`, async function forwardBrowserTraces({ body }) {
+        try {
+          const result = await handleProxy("/v1/traces", body);
+          return new Response(null, { status: result.status });
+        } catch (error) {
+          console.error("[telemetry-proxy] Handler error:", error);
+          return new Response(null, { status: 200 });
+        }
+      }).post(`${PROXY_PATHNAME}/v1/metrics`, async function forwardBrowserMetrics({ body }) {
+        try {
+          const result = await handleProxy("/v1/metrics", body);
+          return new Response(null, { status: result.status });
+        } catch (error) {
+          console.error("[telemetry-proxy] Handler error:", error);
+          return new Response(null, { status: 200 });
+        }
+      }).post(`${PROXY_PATHNAME}/v1/logs`, async function forwardBrowserLogs({ body }) {
+        try {
+          const result = await handleProxy("/v1/logs", body);
+          return new Response(null, { status: result.status });
+        } catch (error) {
+          console.error("[telemetry-proxy] Handler error:", error);
+          return new Response(null, { status: 200 });
+        }
+      }).get(`${PROXY_PATHNAME}/health`, () => {
+        return {
+          status: "ok",
+          otlpEndpoint: OTLP_ENDPOINT,
+          timestamp: new Date().toISOString()
+        };
+      });
+    }
+    return app;
+  };
+}
+var init_plugin = __esm(() => {
+  init_core();
+});
+
+// packages/telemetry/src/server/index.ts
+var init_server = __esm(() => {
+  init_instrumentation();
+  init_plugin();
+});
+
+// packages/telemetry/server.ts
+var init_server2 = __esm(() => {
+  init_server();
+});
+init_server2();
+
+export {
+  withSpanSync,
+  withSpan,
+  withParentSpanSync,
+  withParentSpan,
+  telemetry,
+  setSpanAttributes,
+  addSpanEvent
+};
+
+//# debugId=B91F92BF15BBA06264756E2164756E21