@0xchain/telemetry 1.1.0-beta.2 → 1.1.0-beta.20

package/dist/index.js

@@ -1,98 +1,609 @@
-var S = Object.defineProperty;
-var f = (n, e, t) => e in n ? S(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
-var m = (n, e, t) => f(n, typeof e != "symbol" ? e + "" : e, t);
-import { NodeSDK as g } from "@opentelemetry/sdk-node";
-import { OTLPTraceExporter as E } from "@opentelemetry/exporter-trace-otlp-http";
-import { resourceFromAttributes as I } from "@opentelemetry/resources";
-import { ATTR_SERVICE_VERSION as T, ATTR_SERVICE_NAME as R } from "@opentelemetry/semantic-conventions";
-import { TraceIdRatioBasedSampler as _, AlwaysOnSampler as x, SamplingDecision as l, BatchSpanProcessor as w } from "@opentelemetry/sdk-trace-base";
-import { trace as A, TraceFlags as u } from "@opentelemetry/api";
-import { getNodeAutoInstrumentations as N } from "@opentelemetry/auto-instrumentations-node";
-import { UndiciInstrumentation as P } from "@opentelemetry/instrumentation-undici";
-const y = "deployment.environment.name";
-class D {
-  constructor(e) {
-    m(this, "defaultSampler");
-    m(this, "inspectionSampler");
-    this.defaultSampler = new _(e), this.inspectionSampler = new x();
-  }
-  shouldSample(e, t, r, s, o, i) {
-    if (o["http.request.header.x-inspection"] === "true" || o["x-inspection"] === "true")
-      return this.inspectionSampler.shouldSample(e, t, r, s, o, i);
-    const a = A.getSpanContext(e);
-    return a ? (a.traceFlags & u.SAMPLED) === u.SAMPLED ? { decision: l.RECORD_AND_SAMPLED } : { decision: l.NOT_RECORD } : this.defaultSampler.shouldSample(e, t, r, s, o, i);
-  }
-  toString() {
-    return "InspectionSampler";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { ATTR_SERVICE_VERSION, ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
+import { ATTR_DEPLOYMENT_ENVIRONMENT_NAME } from "@opentelemetry/semantic-conventions/incubating";
+import { SamplingDecision, TraceIdRatioBasedSampler, AlwaysOnSampler, BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { trace, TraceFlags, propagation, context, SpanStatusCode } from "@opentelemetry/api";
+import { readFile } from "node:fs/promises";
+import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
+import { UndiciInstrumentation } from "@opentelemetry/instrumentation-undici";
+import { c as createIgnoreMatcher, m as matchesPathPattern, a as createSpanNameMatcher, d as defaultIgnoreConfig } from "./ignore-BvHZTNsF.js";
+const getHeaderValue = (headers, name) => {
+  if (!headers) return void 0;
+  const value = headers[name.toLowerCase()];
+  if (Array.isArray(value)) {
+    const first = value[0];
+    return typeof first === "string" ? first : void 0;
   }
-}
-const O = [
-  "/health",
-  "/metrics",
-  "/_next/static",
-  "/favicon.ico",
-  "/__nextjs_",
-  "/.well-known"
-], d = (n, e) => n.some((t) => e.includes(t));
-function M(n) {
-  const e = [...O, ...n];
+  return typeof value === "string" ? value : void 0;
+};
+const getPathname = (url) => {
+  if (!url) return "";
+  try {
+    if (url.startsWith("http://") || url.startsWith("https://")) {
+      return new URL(url).pathname;
+    }
+    return new URL(url, "http://localhost").pathname;
+  } catch {
+    return url.split("?")[0] || url;
+  }
+};
+const spanStartTime = /* @__PURE__ */ new WeakMap();
+function getInstrumentations(config) {
+  const shouldIgnore = createIgnoreMatcher(config.ignore);
+  const inspectionHeader = (config.inspectionHeader ?? "x-inspection").toLowerCase();
+  const userTypeHeader = (config.userTypeHeader ?? "x-telemetry-user-type").toLowerCase();
+  const requestStartHeader = (config.requestStartHeader ?? "x-telemetry-start").toLowerCase();
   return [
-    N({
-      // 禁用可能导致问题的检测器
-      "@opentelemetry/instrumentation-grpc": {
-        enabled: !1
+    new HttpInstrumentation({
+      startIncomingSpanHook: (request) => {
+        const headers = "headers" in request ? request.headers : void 0;
+        const inspectionValue = getHeaderValue(headers, inspectionHeader);
+        const userTypeValue = getHeaderValue(headers, userTypeHeader);
+        const startTimeValue = getHeaderValue(headers, requestStartHeader);
+        const method = "method" in request ? request.method : void 0;
+        const pathname = getPathname("url" in request ? request.url : void 0);
+        const startTime = Number(startTimeValue || Date.now());
+        const attributes = {
+          "telemetry.request.start_time_ms": Number.isFinite(startTime) ? startTime : Date.now()
+        };
+        if (pathname) {
+          attributes["url.path"] = pathname;
+        }
+        if (method) {
+          attributes["http.request.method"] = method;
+        }
+        if (inspectionValue) {
+          attributes["telemetry.request.inspection"] = true;
+          attributes["http.request.header.x-inspection"] = inspectionValue;
+        }
+        if (userTypeValue) {
+          attributes["enduser.type"] = userTypeValue;
+          attributes["telemetry.request.user_type"] = userTypeValue;
+        }
+        return attributes;
+      },
+      requestHook: (span, request) => {
+        const headers = "headers" in request ? request.headers : void 0;
+        const startTimeValue = getHeaderValue(headers, requestStartHeader);
+        const startTime = Number(startTimeValue || Date.now());
+        spanStartTime.set(span, Number.isFinite(startTime) ? startTime : Date.now());
+        const method = "method" in request ? request.method || "GET" : "GET";
+        const pathname = getPathname("url" in request ? request.url : void 0);
+        if (pathname) {
+          span.updateName(`${method} ${pathname}`);
+        }
       },
-      "@opentelemetry/instrumentation-http": {
-        enabled: !0,
-        startIncomingSpanHook: (t) => "headers" in t && t.headers["x-inspection"] === "true" ? {
-          "http.request.header.x-inspection": "true",
-          "x-inspection": "true"
-        } : {},
-        ignoreIncomingRequestHook: (t) => {
-          const r = t.url || "";
-          return d(e, r);
-        },
-        ignoreOutgoingRequestHook: (t) => {
-          const r = typeof t == "string" ? t : t.path || "";
-          return d(e, r);
+      responseHook: (span, response) => {
+        const statusCode = "statusCode" in response ? response.statusCode : void 0;
+        if (typeof statusCode === "number") {
+          span.setAttribute("http.response.status_code", statusCode);
+          span.setAttribute("telemetry.response.status_code", statusCode);
+          if (statusCode >= 500) {
+            span.setAttribute("telemetry.request.error", true);
+          }
+        }
+        const startTime = spanStartTime.get(span);
+        if (typeof startTime === "number") {
+          span.setAttribute("telemetry.request.duration_ms", Date.now() - startTime);
         }
+      },
+      ignoreIncomingRequestHook: (request) => {
+        const url = "url" in request ? request.url : void 0;
+        const pathname = getPathname(url);
+        const method = "method" in request ? request.method : void 0;
+        return shouldIgnore(pathname, method);
+      },
+      ignoreOutgoingRequestHook: (request) => {
+        const url = typeof request === "string" ? request : request.path || "";
+        return shouldIgnore(getPathname(url));
       }
     }),
-    new P()
+    new UndiciInstrumentation()
   ];
 }
-let c;
-function j(n) {
-  const {
-    serviceName: e,
-    serviceVersion: t,
-    environment: r,
-    ignorePaths: s = [],
-    inspectionRatio: o = 0.01,
-    ...i
-  } = n, p = I({
-    [R]: e || "ichaingo-seo",
-    [T]: t || "1.0.0",
-    [y]: r || "development"
-  }), a = new E(i), h = new w(a, {
-    scheduledDelayMillis: 1e3,
-    // 1秒延迟
-    maxQueueSize: 2048,
-    maxExportBatchSize: 512
+const toStringValue = (value) => {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    const first = value[0];
+    return typeof first === "string" ? first : void 0;
+  }
+  return void 0;
+};
+const toNumberValue = (value) => {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  if (Array.isArray(value)) {
+    const first = value[0];
+    return toNumberValue(first);
+  }
+  return void 0;
+};
+const pickAttribute = (attributes, keys) => {
+  for (const key of keys) {
+    if (key in attributes) {
+      return attributes[key];
+    }
+  }
+  return void 0;
+};
+const buildSamplingContextFromAttributes = (attributes) => {
+  const pathValue = pickAttribute(attributes, ["url.path", "http.target", "http.route"]);
+  const methodValue = pickAttribute(attributes, ["http.request.method", "http.method"]);
+  const userTypeValue = pickAttribute(attributes, ["enduser.type", "telemetry.request.user_type"]);
+  const statusValue = pickAttribute(attributes, [
+    "http.response.status_code",
+    "http.status_code",
+    "telemetry.response.status_code"
+  ]);
+  const inspectionValue = pickAttribute(attributes, [
+    "telemetry.request.inspection",
+    "http.request.header.x-inspection",
+    "x-inspection"
+  ]);
+  const inspection = inspectionValue === true || inspectionValue === "true" || inspectionValue === "1" || inspectionValue === 1;
+  return {
+    path: toStringValue(pathValue),
+    method: toStringValue(methodValue),
+    userType: toStringValue(userTypeValue),
+    statusCode: toNumberValue(statusValue),
+    inspection
+  };
+};
+const matchStringList = (value, list) => {
+  if (!value || !list?.length) return false;
+  return list.some((item) => item.toLowerCase() === value.toLowerCase());
+};
+const matchPathList = (path, list) => {
+  if (!path || !list?.length) return false;
+  return list.some((pattern) => matchesPathPattern(pattern, path));
+};
+const matchSamplingRule = (rule, context2) => {
+  const condition = rule.when;
+  if (!condition) return true;
+  if (condition.inspection !== void 0 && condition.inspection !== context2.inspection) {
+    return false;
+  }
+  if (condition.path && !matchPathList(context2.path, condition.path)) {
+    return false;
+  }
+  if (condition.method && !matchStringList(context2.method, condition.method)) {
+    return false;
+  }
+  if (condition.userType && !matchStringList(context2.userType, condition.userType)) {
+    return false;
+  }
+  if (condition.statusCode && typeof context2.statusCode === "number") {
+    if (!condition.statusCode.includes(context2.statusCode)) {
+      return false;
+    }
+  } else if (condition.statusCode && condition.statusCode.length) {
+    return false;
+  }
+  if (typeof condition.minStatusCode === "number") {
+    if (typeof context2.statusCode !== "number" || context2.statusCode < condition.minStatusCode) {
+      return false;
+    }
+  }
+  if (typeof condition.maxStatusCode === "number") {
+    if (typeof context2.statusCode !== "number" || context2.statusCode > condition.maxStatusCode) {
+      return false;
+    }
+  }
+  return true;
+};
+const clampRatio = (ratio) => Math.max(0, Math.min(1, ratio));
+const resolveSamplingRatio = (rules, context2, defaultRatio) => {
+  if (!rules?.length) return clampRatio(defaultRatio);
+  for (const rule of rules) {
+    if (matchSamplingRule(rule, context2)) {
+      return clampRatio(rule.ratio);
+    }
+  }
+  return clampRatio(defaultRatio);
+};
+const samplerCache = /* @__PURE__ */ new Map();
+const getSamplerForRatio = (ratio) => {
+  if (ratio <= 0) {
+    return new TraceIdRatioBasedSampler(0);
+  }
+  if (ratio >= 1) {
+    return new AlwaysOnSampler();
+  }
+  const normalized = Number(ratio.toFixed(6));
+  const cached = samplerCache.get(normalized);
+  if (cached) return cached;
+  const sampler = new TraceIdRatioBasedSampler(normalized);
+  samplerCache.set(normalized, sampler);
+  return sampler;
+};
+const getSpanNameMatcher = (config, cache) => {
+  if (config !== cache.ignore) {
+    cache.ignore = config;
+    cache.matcher = createSpanNameMatcher(config);
+  }
+  return cache.matcher;
+};
+const createRuleBasedSampler = (runtime2) => {
+  const matcherCache = {};
+  return {
+    shouldSample(context2, traceId, spanName, spanKind, attributes, links) {
+      const parentContext = trace.getSpanContext(context2);
+      if (parentContext) {
+        if (parentContext.isRemote) {
+          const config2 = runtime2.getConfig();
+          const matcher2 = getSpanNameMatcher(config2.ignore, matcherCache);
+          if (matcher2?.(spanName)) {
+            return { decision: SamplingDecision.NOT_RECORD };
+          }
+        }
+        if ((parentContext.traceFlags & TraceFlags.SAMPLED) === TraceFlags.SAMPLED) {
+          return { decision: SamplingDecision.RECORD_AND_SAMPLED };
+        }
+        return { decision: SamplingDecision.NOT_RECORD };
+      }
+      const config = runtime2.getConfig();
+      const matcher = getSpanNameMatcher(config.ignore, matcherCache);
+      if (matcher?.(spanName)) {
+        return { decision: SamplingDecision.NOT_RECORD };
+      }
+      const samplingContext = buildSamplingContextFromAttributes(attributes);
+      if (samplingContext.inspection) {
+        return { decision: SamplingDecision.RECORD_AND_SAMPLED };
+      }
+      const ratio = resolveSamplingRatio(
+        config.samplingRules,
+        samplingContext,
+        config.defaultSamplingRatio ?? 0.01
+      );
+      return getSamplerForRatio(ratio).shouldSample(context2, traceId, spanName, spanKind, attributes, links);
+    },
+    toString: () => "RuleBasedSampler"
+  };
+};
+const createFilteringTraceExporter = (exporter) => exporter;
+let sdk;
+let runtime;
+const uniqueList = (items) => Array.from(new Set(items));
+const parseList = (value) => value?.split(",").map((item) => item.trim()).filter(Boolean) ?? [];
+const parseHeaders = (value) => {
+  if (!value) return void 0;
+  const headers = {};
+  for (const pair of value.split(",")) {
+    const [key, ...rest] = pair.split("=");
+    const normalizedKey = key?.trim();
+    if (!normalizedKey) continue;
+    headers[normalizedKey] = rest.join("=").trim();
+  }
+  return headers;
+};
+const parseJson = (value) => {
+  if (!value) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+};
+const readConfigFile = async (path) => {
+  if (!path) return void 0;
+  try {
+    const raw = await readFile(path, "utf8");
+    return parseJson(raw);
+  } catch {
+    return void 0;
+  }
+};
+const mergeIgnoreConfig = (base, overrides) => {
+  const mergedPaths = uniqueList([...base?.paths ?? [], ...overrides?.paths ?? []]);
+  const mergedExtensions = uniqueList([
+    ...base?.extensions ?? [],
+    ...overrides?.extensions ?? []
+  ]);
+  const mergedMethods = uniqueList([...base?.methods ?? [], ...overrides?.methods ?? []]);
+  const mergedSpanNames = uniqueList([...base?.spanNames ?? [], ...overrides?.spanNames ?? []]);
+  return {
+    paths: mergedPaths.length ? mergedPaths : void 0,
+    extensions: mergedExtensions.length ? mergedExtensions : void 0,
+    methods: mergedMethods.length ? mergedMethods : void 0,
+    spanNames: mergedSpanNames.length ? mergedSpanNames : void 0
+  };
+};
+const normalizeSamplingRules = (rules) => {
+  if (!rules?.length) return void 0;
+  return rules.map((rule) => ({
+    ...rule,
+    ratio: Number.isFinite(rule.ratio) ? Math.max(0, Math.min(1, rule.ratio)) : 0
+  })).filter((rule) => rule.ratio >= 0);
+};
+const loadTelemetryConfigFromEnv = async (env = process.env) => {
+  const fileConfig = await readConfigFile(env.TELEMETRY_CONFIG_FILE);
+  const ignorePaths = parseList(env.TELEMETRY_IGNORE_PATHS);
+  const ignoreExtensions = parseList(env.TELEMETRY_IGNORE_EXTENSIONS);
+  const ignoreMethods = parseList(env.TELEMETRY_IGNORE_METHODS);
+  const samplingRules = parseJson(env.TELEMETRY_SAMPLING_RULES);
+  const fileSamplingRules = typeof fileConfig?.samplingRules === "string" ? parseJson(fileConfig.samplingRules) : fileConfig?.samplingRules;
+  const envConfig = {
+    serviceName: env.OTEL_SERVICE_NAME || env.TELEMETRY_SERVICE_NAME,
+    serviceVersion: env.OTEL_SERVICE_VERSION || env.TELEMETRY_SERVICE_VERSION,
+    environment: env.OTEL_RESOURCE_ATTRIBUTES || env.TELEMETRY_ENVIRONMENT || (env.VERCEL ? env.VERCEL_ENV : void 0),
+    defaultSamplingRatio: env.TELEMETRY_SAMPLING_RATIO ? Number(env.TELEMETRY_SAMPLING_RATIO) : void 0,
+    url: env.OTEL_EXPORTER_OTLP_ENDPOINT || env.TELEMETRY_OTLP_ENDPOINT,
+    headers: parseHeaders(env.OTEL_EXPORTER_OTLP_HEADERS || env.TELEMETRY_OTLP_HEADERS),
+    inspectionHeader: env.TELEMETRY_INSPECTION_HEADER,
+    userTypeHeader: env.TELEMETRY_USER_TYPE_HEADER,
+    requestStartHeader: env.TELEMETRY_REQUEST_START_HEADER,
+    samplingRules: samplingRules || fileSamplingRules,
+    ignore: ignorePaths.length || ignoreExtensions.length || ignoreMethods.length ? {
+      paths: ignorePaths.length ? ignorePaths : void 0,
+      extensions: ignoreExtensions.length ? ignoreExtensions : void 0,
+      methods: ignoreMethods.length ? ignoreMethods : void 0
+    } : void 0
+  };
+  if (fileConfig && typeof fileConfig === "object") {
+    return { ...fileConfig, ...envConfig };
+  }
+  return envConfig;
+};
+const resolveEnvironmentName = (environment) => {
+  if (!environment) return process.env.NODE_ENV || "development";
+  if (environment.includes("deployment.environment")) {
+    const entries = environment.split(",");
+    const match = entries.find((entry) => entry.includes("deployment.environment"));
+    if (!match) return environment;
+    const [, value] = match.split("=");
+    return value?.trim() || environment;
+  }
+  return environment;
+};
+const buildLayeredSamplingRules = (layered, defaultRatio) => {
+  const rules = [
+    { name: "inspection", ratio: 1, when: { inspection: true } },
+    { name: "error", ratio: 1, when: { minStatusCode: 500 } }
+  ];
+  if (layered?.criticalPaths?.length) {
+    rules.push({
+      name: "critical-path",
+      ratio: 1,
+      when: { path: layered.criticalPaths }
+    });
+  }
+  if (layered?.criticalUserTypes?.length) {
+    rules.push({
+      name: "critical-user",
+      ratio: 1,
+      when: { userType: layered.criticalUserTypes }
+    });
+  }
+  if (layered?.pathSampling) {
+    for (const [pattern, ratio] of Object.entries(layered.pathSampling)) {
+      rules.push({
+        name: `path:${pattern}`,
+        ratio,
+        when: { path: [pattern] }
+      });
+    }
+  }
+  if (layered?.userTypeSampling) {
+    for (const [userType, ratio] of Object.entries(layered.userTypeSampling)) {
+      rules.push({
+        name: `user:${userType}`,
+        ratio,
+        when: { userType: [userType] }
+      });
+    }
+  }
+  rules.push({ name: "default", ratio: defaultRatio });
+  return rules;
+};
+const normalizeResolvedConfig = (merged) => {
+  const environment = resolveEnvironmentName(merged.environment);
+  const ignore = mergeIgnoreConfig(defaultIgnoreConfig, merged.ignore);
+  const defaultSamplingRatio = typeof merged.defaultSamplingRatio === "number" ? Math.max(0, Math.min(1, merged.defaultSamplingRatio)) : 0.01;
+  const samplingRules = normalizeSamplingRules(merged.samplingRules) ?? buildLayeredSamplingRules(merged.layeredSampling, defaultSamplingRatio);
+  return {
+    ...merged,
+    serviceName: merged.serviceName || "unknown-service",
+    serviceVersion: merged.serviceVersion,
+    environment,
+    defaultSamplingRatio,
+    ignore,
+    samplingRules,
+    inspectionHeader: merged.inspectionHeader ?? "x-inspection",
+    userTypeHeader: merged.userTypeHeader ?? "x-telemetry-user-type",
+    requestStartHeader: merged.requestStartHeader ?? "x-telemetry-start",
+    scheduledDelayMillis: merged.scheduledDelayMillis ?? 1e3,
+    maxQueueSize: merged.maxQueueSize ?? 2048,
+    maxExportBatchSize: merged.maxExportBatchSize ?? 512,
+    exporterTimeoutMillis: merged.exporterTimeoutMillis ?? 3e4
+  };
+};
+const resolveTelemetryConfig = async (options = {}, env = process.env) => {
+  const envConfig = await loadTelemetryConfigFromEnv(env);
+  return normalizeResolvedConfig({ ...envConfig, ...options });
+};
+const createTelemetryRuntime = async (initialConfig) => {
+  let current = await resolveTelemetryConfig(initialConfig);
+  return {
+    getConfig: () => current,
+    updateConfig: (partial) => {
+      current = normalizeResolvedConfig({
+        ...current,
+        ...partial,
+        ignore: mergeIgnoreConfig(current.ignore, partial.ignore)
+      });
+    }
+  };
+};
+const hrTimeToMilliseconds = (time) => time[0] * 1e3 + time[1] / 1e6;
+const getSpanAttributeNumber = (span, keys) => {
+  for (const key of keys) {
+    const value = span.attributes[key];
+    if (typeof value === "number") return value;
+  }
+  return void 0;
+};
+const extractExceptionMessage = (span) => {
+  const exceptionEvent = span.events.find((event) => event.name === "exception");
+  if (!exceptionEvent?.attributes) return void 0;
+  const message = exceptionEvent.attributes["exception.message"];
+  return typeof message === "string" ? message : void 0;
+};
+const BARE_HTTP_METHOD = /^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)$/;
+const extractPathFromSpanAttributes = (attrs) => {
+  for (const key of ["url.path", "http.target", "http.route", "next.route"]) {
+    const val = attrs[key];
+    if (val && typeof val === "string") return val;
+  }
+  const url = attrs["http.url"] ?? attrs["url.full"];
+  if (url && typeof url === "string") {
+    try {
+      return new URL(url).pathname;
+    } catch {
+      return url.split("?")[0];
+    }
+  }
+  return void 0;
+};
+const createSpanNamingProcessor = () => {
+  return {
+    onStart: (span) => {
+      const sdkSpan = span;
+      const name = sdkSpan.name;
+      if (!name || !BARE_HTTP_METHOD.test(name)) return;
+      const path = extractPathFromSpanAttributes(sdkSpan.attributes);
+      if (path) {
+        span.updateName(`${name} ${path}`);
+      }
+    },
+    onEnd: (span) => {
+      const name = span.name;
+      if (!name || !BARE_HTTP_METHOD.test(name)) return;
+      const path = extractPathFromSpanAttributes(span.attributes);
+      if (!path) return;
+      const method = span.attributes["http.request.method"] ?? span.attributes["http.method"];
+      const resolvedMethod = typeof method === "string" ? method : name;
+      span.name = `${resolvedMethod} ${path}`;
+    },
+    shutdown: () => Promise.resolve(),
+    forceFlush: () => Promise.resolve()
+  };
+};
+const createRequestSpanProcessor = () => {
+  return {
+    onStart: () => void 0,
+    onEnd: (span) => {
+      const durationMs = hrTimeToMilliseconds(span.duration);
+      span.attributes["telemetry.request.duration_ms"] = Math.round(durationMs);
+      if (typeof span.attributes["telemetry.request.start_time_ms"] !== "number") {
+        span.attributes["telemetry.request.start_time_ms"] = Date.now() - Math.round(durationMs);
+      }
+      const statusCode = getSpanAttributeNumber(span, [
+        "http.response.status_code",
+        "http.status_code",
+        "telemetry.response.status_code"
+      ]);
+      if (typeof statusCode === "number") {
+        span.attributes["telemetry.response.status_code"] = statusCode;
+      }
+      const isError = span.status.code === SpanStatusCode.ERROR || typeof statusCode === "number" && statusCode >= 500;
+      if (isError) {
+        span.attributes["telemetry.request.error"] = true;
+        const message = span.status.message || extractExceptionMessage(span);
+        if (message) {
+          span.attributes["telemetry.request.error_message"] = message;
+        }
+      }
+    },
+    shutdown: () => Promise.resolve(),
+    forceFlush: () => Promise.resolve()
+  };
+};
+const startTelemetry = async (options) => {
+  const config = await resolveTelemetryConfig(options);
+  runtime = await createTelemetryRuntime(config);
+  const env = process.env;
+  const resourceAttrs = {
+    [ATTR_SERVICE_NAME]: config.serviceName,
+    [ATTR_SERVICE_VERSION]: config.serviceVersion || "1.0.0",
+    [ATTR_DEPLOYMENT_ENVIRONMENT_NAME]: config.environment || env.VERCEL_ENV || env.NODE_ENV || "development"
+  };
+  if (env.VERCEL) {
+    if (env.VERCEL_REGION) resourceAttrs["vercel.region"] = env.VERCEL_REGION;
+    if (env.NEXT_RUNTIME) resourceAttrs["vercel.runtime"] = env.NEXT_RUNTIME;
+    if (env.VERCEL_GIT_COMMIT_SHA) resourceAttrs["vercel.sha"] = env.VERCEL_GIT_COMMIT_SHA;
+    if (env.VERCEL_URL) resourceAttrs["vercel.host"] = env.VERCEL_URL;
+    if (env.VERCEL_BRANCH_URL) resourceAttrs["vercel.branch_host"] = env.VERCEL_BRANCH_URL;
+    if (env.VERCEL_DEPLOYMENT_ID) resourceAttrs["vercel.deployment_id"] = env.VERCEL_DEPLOYMENT_ID;
+  }
+  const resource = resourceFromAttributes(resourceAttrs);
+  const traceExporter = new OTLPTraceExporter(config);
+  const filteringExporter = createFilteringTraceExporter(traceExporter);
+  const spanProcessors = [
+    createSpanNamingProcessor(),
+    createRequestSpanProcessor(),
+    new BatchSpanProcessor(filteringExporter, {
+      scheduledDelayMillis: config.scheduledDelayMillis,
+      maxQueueSize: config.maxQueueSize,
+      maxExportBatchSize: config.maxExportBatchSize,
+      exportTimeoutMillis: config.exporterTimeoutMillis
+    })
+  ];
+  sdk = new NodeSDK({
+    serviceName: config.serviceName,
+    resource,
+    spanProcessors,
+    sampler: createRuleBasedSampler(runtime),
+    instrumentations: getInstrumentations(config)
   });
-  c = new g({
-    serviceName: e,
-    resource: p,
-    spanProcessors: [h],
-    sampler: new D(o),
-    // traceExporter,
-    instrumentations: M(s)
-  }), c.start(), console.log("OpenTelemetry started:", JSON.stringify(n, null, 2));
-}
-function q() {
-  c && c.shutdown();
-}
+  try {
+    await sdk.start();
+  } catch (error) {
+    console.warn("Telemetry start failed:", error);
+  }
+  return runtime;
+};
+const updateTelemetryConfig = (partial) => {
+  runtime?.updateConfig(partial);
+};
+const injectTraceHeaders = (headers) => {
+  propagation.inject(context.active(), headers);
+  return headers;
+};
+const createPropagatingFetch = (fetchImpl = fetch) => {
+  return async (input, init) => {
+    const baseHeaders = init?.headers ?? (input instanceof Request ? input.headers : void 0);
+    const headers = new Headers(baseHeaders);
+    propagation.inject(context.active(), headers, {
+      set: (carrier, key, value) => {
+        carrier.set(key, value);
+      }
+    });
+    return fetchImpl(input, { ...init, headers });
+  };
+};
+const shutdownTelemetry = async () => {
+  if (sdk) {
+    await sdk.shutdown();
+  }
+};
 export {
-  q as shutdownTelemetry,
-  j as startTelemetry
+  buildSamplingContextFromAttributes,
+  createIgnoreMatcher,
+  createPropagatingFetch,
+  createSpanNameMatcher,
+  createTelemetryRuntime,
+  defaultIgnoreConfig,
+  injectTraceHeaders,
+  loadTelemetryConfigFromEnv,
+  matchSamplingRule,
+  resolveSamplingRatio,
+  resolveTelemetryConfig,
+  shutdownTelemetry,
+  startTelemetry,
+  updateTelemetryConfig
 };