@0xchain/telemetry 1.1.0-beta.17 → 1.1.0-beta.19

package/dist/index.js

@@ -1,395 +1,609 @@
-import { NodeSDK as F } from "@opentelemetry/sdk-node";
-import { OTLPTraceExporter as Y } from "@opentelemetry/exporter-trace-otlp-http";
-import { resourceFromAttributes as U } from "@opentelemetry/resources";
-import { ATTR_SERVICE_VERSION as G, ATTR_SERVICE_NAME as q } from "@opentelemetry/semantic-conventions";
-import { SamplingDecision as d, TraceIdRatioBasedSampler as L, AlwaysOnSampler as B, BatchSpanProcessor as k } from "@opentelemetry/sdk-trace-base";
-import { trace as z, TraceFlags as M, propagation as V, context as x, SpanStatusCode as $ } from "@opentelemetry/api";
-import { readFile as j } from "node:fs/promises";
-import { HttpInstrumentation as Q } from "@opentelemetry/instrumentation-http";
-import { UndiciInstrumentation as X } from "@opentelemetry/instrumentation-undici";
-import { c as W, m as J, a as K, d as Z } from "./ignore-CMi2r3b2.js";
-const tt = "deployment.environment.name", T = (t, e) => {
-  if (!t) return;
-  const r = t[e.toLowerCase()];
-  if (Array.isArray(r)) {
-    const n = r[0];
-    return typeof n == "string" ? n : void 0;
-  }
-  return typeof r == "string" ? r : void 0;
-}, R = (t) => {
-  if (!t) return "";
+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;
+  }
+  return typeof value === "string" ? value : void 0;
+};
+const getPathname = (url) => {
+  if (!url) return "";
   try {
-    return t.startsWith("http://") || t.startsWith("https://") ? new URL(t).pathname : new URL(t, "http://localhost").pathname;
+    if (url.startsWith("http://") || url.startsWith("https://")) {
+      return new URL(url).pathname;
+    }
+    return new URL(url, "http://localhost").pathname;
   } catch {
-    return t.split("?")[0] || t;
+    return url.split("?")[0] || url;
   }
-}, O = /* @__PURE__ */ new WeakMap();
-function et(t) {
-  const e = W(t.ignore), r = (t.inspectionHeader ?? "x-inspection").toLowerCase(), n = (t.userTypeHeader ?? "x-telemetry-user-type").toLowerCase(), s = (t.requestStartHeader ?? "x-telemetry-start").toLowerCase();
+};
+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 [
-    new Q({
-      startIncomingSpanHook: (o) => {
-        const i = "headers" in o ? o.headers : void 0, a = T(i, r), c = T(i, n), p = T(i, s), u = "method" in o ? o.method : void 0, m = R("url" in o ? o.url : void 0), f = Number(p || Date.now()), E = {
-          "telemetry.request.start_time_ms": Number.isFinite(f) ? f : Date.now()
+    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()
         };
-        return m && (E["url.path"] = m), u && (E["http.request.method"] = u), a && (E["telemetry.request.inspection"] = !0, E["http.request.header.x-inspection"] = a), c && (E["enduser.type"] = c, E["telemetry.request.user_type"] = c), E;
+        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: (o, i) => {
-        const a = "headers" in i ? i.headers : void 0, c = T(a, s), p = Number(c || Date.now());
-        O.set(o, Number.isFinite(p) ? p : Date.now());
-        const u = "method" in i && i.method || "GET", m = R("url" in i ? i.url : void 0);
-        m && o.updateName(`${u} ${m}`);
+      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}`);
+        }
       },
-      responseHook: (o, i) => {
-        const a = "statusCode" in i ? i.statusCode : void 0;
-        typeof a == "number" && (o.setAttribute("http.response.status_code", a), o.setAttribute("telemetry.response.status_code", a), a >= 500 && o.setAttribute("telemetry.request.error", !0));
-        const c = O.get(o);
-        typeof c == "number" && o.setAttribute("telemetry.request.duration_ms", Date.now() - c);
+      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: (o) => {
-        const i = "url" in o ? o.url : void 0, a = R(i), c = "method" in o ? o.method : void 0;
-        return e(a, c);
+      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: (o) => {
-        const i = typeof o == "string" ? o : o.path || "";
-        return e(R(i));
+      ignoreOutgoingRequestHook: (request) => {
+        const url = typeof request === "string" ? request : request.path || "";
+        return shouldIgnore(getPathname(url));
       }
     }),
-    new X()
+    new UndiciInstrumentation()
   ];
 }
-const S = (t) => {
-  if (typeof t == "string") return t;
-  if (Array.isArray(t)) {
-    const e = t[0];
-    return typeof e == "string" ? e : void 0;
-  }
-}, H = (t) => {
-  if (typeof t == "number") return t;
-  if (typeof t == "string") {
-    const e = Number(t);
-    return Number.isFinite(e) ? e : void 0;
-  }
-  if (Array.isArray(t)) {
-    const e = t[0];
-    return H(e);
-  }
-}, l = (t, e) => {
-  for (const r of e)
-    if (r in t)
-      return t[r];
-}, rt = (t) => {
-  const e = l(t, ["url.path", "http.target", "http.route"]), r = l(t, ["http.request.method", "http.method"]), n = l(t, ["enduser.type", "telemetry.request.user_type"]), s = l(t, [
+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"
-  ]), o = l(t, [
+  ]);
+  const inspectionValue = pickAttribute(attributes, [
     "telemetry.request.inspection",
     "http.request.header.x-inspection",
     "x-inspection"
-  ]), i = o === !0 || o === "true" || o === "1" || o === 1;
+  ]);
+  const inspection = inspectionValue === true || inspectionValue === "true" || inspectionValue === "1" || inspectionValue === 1;
   return {
-    path: S(e),
-    method: S(r),
-    userType: S(n),
-    statusCode: H(s),
-    inspection: i
+    path: toStringValue(pathValue),
+    method: toStringValue(methodValue),
+    userType: toStringValue(userTypeValue),
+    statusCode: toNumberValue(statusValue),
+    inspection
   };
-}, A = (t, e) => !t || !(e != null && e.length) ? !1 : e.some((r) => r.toLowerCase() === t.toLowerCase()), nt = (t, e) => !t || !(e != null && e.length) ? !1 : e.some((r) => J(r, t)), ot = (t, e) => {
-  const r = t.when;
-  if (!r) return !0;
-  if (r.inspection !== void 0 && r.inspection !== e.inspection || r.path && !nt(e.path, r.path) || r.method && !A(e.method, r.method) || r.userType && !A(e.userType, r.userType))
-    return !1;
-  if (r.statusCode && typeof e.statusCode == "number") {
-    if (!r.statusCode.includes(e.statusCode))
-      return !1;
-  } else if (r.statusCode && r.statusCode.length)
-    return !1;
-  return !(typeof r.minStatusCode == "number" && (typeof e.statusCode != "number" || e.statusCode < r.minStatusCode) || typeof r.maxStatusCode == "number" && (typeof e.statusCode != "number" || e.statusCode > r.maxStatusCode));
-}, y = (t) => Math.max(0, Math.min(1, t)), st = (t, e, r) => {
-  if (!(t != null && t.length)) return y(r);
-  for (const n of t)
-    if (ot(n, e))
-      return y(n.ratio);
-  return y(r);
-}, w = /* @__PURE__ */ new Map(), it = (t) => {
-  if (t <= 0)
-    return new L(0);
-  if (t >= 1)
-    return new B();
-  const e = Number(t.toFixed(6)), r = w.get(e);
-  if (r) return r;
-  const n = new L(e);
-  return w.set(e, n), n;
-}, at = (t) => {
-  let e, r;
+};
+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(n, s, o, i, a, c) {
-      const p = z.getSpanContext(n);
-      if (p)
-        return (p.traceFlags & M.SAMPLED) === M.SAMPLED ? { decision: d.RECORD_AND_SAMPLED } : { decision: d.NOT_RECORD };
-      const u = t.getConfig();
-      if (u.ignore !== e && (e = u.ignore, r = K(u.ignore)), r != null && r(o))
-        return { decision: d.NOT_RECORD };
-      const m = rt(a);
-      if (m.inspection)
-        return { decision: d.RECORD_AND_SAMPLED };
-      const f = st(
-        u.samplingRules,
-        m,
-        u.defaultSamplingRatio ?? 0.01
+    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 it(f).shouldSample(n, s, o, i, a, c);
+      return getSamplerForRatio(ratio).shouldSample(context2, traceId, spanName, spanKind, attributes, links);
     },
     toString: () => "RuleBasedSampler"
   };
-}, ct = (t) => t;
-let _, h;
-const g = (t) => Array.from(new Set(t)), N = (t) => (t == null ? void 0 : t.split(",").map((e) => e.trim()).filter(Boolean)) ?? [], ut = (t) => {
-  if (!t) return;
-  const e = {};
-  for (const r of t.split(",")) {
-    const [n, ...s] = r.split("="), o = n == null ? void 0 : n.trim();
-    o && (e[o] = s.join("=").trim());
-  }
-  return e;
-}, C = (t) => {
-  if (t)
-    try {
-      return JSON.parse(t);
-    } catch {
-      return;
-    }
-}, mt = async (t) => {
-  if (t)
-    try {
-      const e = await j(t, "utf8");
-      return C(e);
-    } catch {
-      return;
-    }
-}, D = (t, e) => {
-  const r = g([...(t == null ? void 0 : t.paths) ?? [], ...(e == null ? void 0 : e.paths) ?? []]), n = g([
-    ...(t == null ? void 0 : t.extensions) ?? [],
-    ...(e == null ? void 0 : e.extensions) ?? []
-  ]), s = g([...(t == null ? void 0 : t.methods) ?? [], ...(e == null ? void 0 : e.methods) ?? []]), o = g([...(t == null ? void 0 : t.spanNames) ?? [], ...(e == null ? void 0 : e.spanNames) ?? []]);
+};
+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: r.length ? r : void 0,
-    extensions: n.length ? n : void 0,
-    methods: s.length ? s : void 0,
-    spanNames: o.length ? o : void 0
+    paths: mergedPaths.length ? mergedPaths : void 0,
+    extensions: mergedExtensions.length ? mergedExtensions : void 0,
+    methods: mergedMethods.length ? mergedMethods : void 0,
+    spanNames: mergedSpanNames.length ? mergedSpanNames : void 0
   };
-}, pt = (t) => {
-  if (t != null && t.length)
-    return t.map((e) => ({
-      ...e,
-      ratio: Number.isFinite(e.ratio) ? Math.max(0, Math.min(1, e.ratio)) : 0
-    })).filter((e) => e.ratio >= 0);
-}, Et = async (t = process.env) => {
-  const e = await mt(t.TELEMETRY_CONFIG_FILE), r = N(t.TELEMETRY_IGNORE_PATHS), n = N(t.TELEMETRY_IGNORE_EXTENSIONS), s = N(t.TELEMETRY_IGNORE_METHODS), o = C(t.TELEMETRY_SAMPLING_RULES), i = typeof (e == null ? void 0 : e.samplingRules) == "string" ? C(e.samplingRules) : e == null ? void 0 : e.samplingRules, a = {
-    serviceName: t.OTEL_SERVICE_NAME || t.TELEMETRY_SERVICE_NAME,
-    serviceVersion: t.OTEL_SERVICE_VERSION || t.TELEMETRY_SERVICE_VERSION,
-    environment: t.OTEL_RESOURCE_ATTRIBUTES || t.TELEMETRY_ENVIRONMENT || (t.VERCEL ? t.VERCEL_ENV : void 0),
-    defaultSamplingRatio: t.TELEMETRY_SAMPLING_RATIO ? Number(t.TELEMETRY_SAMPLING_RATIO) : void 0,
-    url: t.OTEL_EXPORTER_OTLP_ENDPOINT || t.TELEMETRY_OTLP_ENDPOINT,
-    headers: ut(t.OTEL_EXPORTER_OTLP_HEADERS || t.TELEMETRY_OTLP_HEADERS),
-    inspectionHeader: t.TELEMETRY_INSPECTION_HEADER,
-    userTypeHeader: t.TELEMETRY_USER_TYPE_HEADER,
-    requestStartHeader: t.TELEMETRY_REQUEST_START_HEADER,
-    samplingRules: o || i,
-    ignore: r.length || n.length || s.length ? {
-      paths: r.length ? r : void 0,
-      extensions: n.length ? n : void 0,
-      methods: s.length ? s : 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
   };
-  return e && typeof e == "object" ? { ...e, ...a } : a;
-}, ht = (t) => {
-  if (!t) return process.env.NODE_ENV || "development";
-  if (t.includes("deployment.environment")) {
-    const r = t.split(",").find((s) => s.includes("deployment.environment"));
-    if (!r) return t;
-    const [, n] = r.split("=");
-    return (n == null ? void 0 : n.trim()) || t;
-  }
-  return t;
-}, lt = (t, e) => {
-  var n, s;
-  const r = [
-    { name: "inspection", ratio: 1, when: { inspection: !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 ((n = t == null ? void 0 : t.criticalPaths) != null && n.length && r.push({
-    name: "critical-path",
-    ratio: 1,
-    when: { path: t.criticalPaths }
-  }), (s = t == null ? void 0 : t.criticalUserTypes) != null && s.length && r.push({
-    name: "critical-user",
-    ratio: 1,
-    when: { userType: t.criticalUserTypes }
-  }), t != null && t.pathSampling)
-    for (const [o, i] of Object.entries(t.pathSampling))
-      r.push({
-        name: `path:${o}`,
-        ratio: i,
-        when: { path: [o] }
+  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 (t != null && t.userTypeSampling)
-    for (const [o, i] of Object.entries(t.userTypeSampling))
-      r.push({
-        name: `user:${o}`,
-        ratio: i,
-        when: { userType: [o] }
+    }
+  }
+  if (layered?.userTypeSampling) {
+    for (const [userType, ratio] of Object.entries(layered.userTypeSampling)) {
+      rules.push({
+        name: `user:${userType}`,
+        ratio,
+        when: { userType: [userType] }
       });
-  return r.push({ name: "default", ratio: e }), r;
-}, b = (t) => {
-  const e = ht(t.environment), r = D(Z, t.ignore), n = typeof t.defaultSamplingRatio == "number" ? Math.max(0, Math.min(1, t.defaultSamplingRatio)) : 0.01, s = pt(t.samplingRules) ?? lt(t.layeredSampling, n);
+    }
+  }
+  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 {
-    ...t,
-    serviceName: t.serviceName || "unknown-service",
-    serviceVersion: t.serviceVersion,
-    environment: e,
-    defaultSamplingRatio: n,
-    ignore: r,
-    samplingRules: s,
-    inspectionHeader: t.inspectionHeader ?? "x-inspection",
-    userTypeHeader: t.userTypeHeader ?? "x-telemetry-user-type",
-    requestStartHeader: t.requestStartHeader ?? "x-telemetry-start",
-    scheduledDelayMillis: t.scheduledDelayMillis ?? 1e3,
-    maxQueueSize: t.maxQueueSize ?? 2048,
-    maxExportBatchSize: t.maxExportBatchSize ?? 512,
-    exporterTimeoutMillis: t.exporterTimeoutMillis ?? 3e4
+    ...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
   };
-}, v = async (t = {}, e = process.env) => {
-  const r = await Et(e);
-  return b({ ...r, ...t });
-}, ft = async (t) => {
-  let e = await v(t);
+};
+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: () => e,
-    updateConfig: (r) => {
-      e = b({
-        ...e,
-        ...r,
-        ignore: D(e.ignore, r.ignore)
+    getConfig: () => current,
+    updateConfig: (partial) => {
+      current = normalizeResolvedConfig({
+        ...current,
+        ...partial,
+        ignore: mergeIgnoreConfig(current.ignore, partial.ignore)
       });
     }
   };
-}, dt = (t) => t[0] * 1e3 + t[1] / 1e6, Tt = (t, e) => {
-  for (const r of e) {
-    const n = t.attributes[r];
-    if (typeof n == "number") return n;
-  }
-}, Rt = (t) => {
-  const e = t.events.find((n) => n.name === "exception");
-  if (!(e != null && e.attributes)) return;
-  const r = e.attributes["exception.message"];
-  return typeof r == "string" ? r : void 0;
-}, I = /^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS)$/, P = (t) => {
-  for (const r of ["url.path", "http.target", "http.route", "next.route"]) {
-    const n = t[r];
-    if (n && typeof n == "string") return n;
-  }
-  const e = t["http.url"] ?? t["url.full"];
-  if (e && typeof e == "string")
+};
+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(e).pathname;
+      return new URL(url).pathname;
     } catch {
-      return e.split("?")[0];
-    }
-}, gt = () => ({
-  onStart: (t) => {
-    const e = t, r = e.name;
-    if (!r || !I.test(r)) return;
-    const n = P(e.attributes);
-    n && t.updateName(`${r} ${n}`);
-  },
-  onEnd: (t) => {
-    const e = t.name;
-    if (!e || !I.test(e)) return;
-    const r = P(t.attributes);
-    if (!r) return;
-    const n = t.attributes["http.request.method"] ?? t.attributes["http.method"], s = typeof n == "string" ? n : e;
-    t.name = `${s} ${r}`;
-  },
-  shutdown: () => Promise.resolve(),
-  forceFlush: () => Promise.resolve()
-}), _t = () => ({
-  onStart: () => {
-  },
-  onEnd: (t) => {
-    const e = dt(t.duration);
-    t.attributes["telemetry.request.duration_ms"] = Math.round(e), typeof t.attributes["telemetry.request.start_time_ms"] != "number" && (t.attributes["telemetry.request.start_time_ms"] = Date.now() - Math.round(e));
-    const r = Tt(t, [
-      "http.response.status_code",
-      "http.status_code",
-      "telemetry.response.status_code"
-    ]);
-    if (typeof r == "number" && (t.attributes["telemetry.response.status_code"] = r), t.status.code === $.ERROR || typeof r == "number" && r >= 500) {
-      t.attributes["telemetry.request.error"] = !0;
-      const s = t.status.message || Rt(t);
-      s && (t.attributes["telemetry.request.error_message"] = s);
+      return url.split("?")[0];
     }
-  },
-  shutdown: () => Promise.resolve(),
-  forceFlush: () => Promise.resolve()
-}), Pt = async (t) => {
-  const e = await v(t);
-  h = await ft(e);
-  const r = process.env, n = {
-    [q]: e.serviceName,
-    [G]: e.serviceVersion || "1.0.0",
-    [tt]: e.environment || r.VERCEL_ENV || r.NODE_ENV || "development"
+  }
+  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()
   };
-  r.VERCEL && (r.VERCEL_REGION && (n["vercel.region"] = r.VERCEL_REGION), r.NEXT_RUNTIME && (n["vercel.runtime"] = r.NEXT_RUNTIME), r.VERCEL_GIT_COMMIT_SHA && (n["vercel.sha"] = r.VERCEL_GIT_COMMIT_SHA), r.VERCEL_URL && (n["vercel.host"] = r.VERCEL_URL), r.VERCEL_BRANCH_URL && (n["vercel.branch_host"] = r.VERCEL_BRANCH_URL), r.VERCEL_DEPLOYMENT_ID && (n["vercel.deployment_id"] = r.VERCEL_DEPLOYMENT_ID));
-  const s = U(n), o = new Y(e), i = ct(o), a = [
-    gt(),
-    _t(),
-    new k(i, {
-      scheduledDelayMillis: e.scheduledDelayMillis,
-      maxQueueSize: e.maxQueueSize,
-      maxExportBatchSize: e.maxExportBatchSize,
-      exportTimeoutMillis: e.exporterTimeoutMillis
+};
+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
     })
   ];
-  _ = new F({
-    serviceName: e.serviceName,
-    resource: s,
-    spanProcessors: a,
-    sampler: at(h),
-    instrumentations: et(e)
+  sdk = new NodeSDK({
+    serviceName: config.serviceName,
+    resource,
+    spanProcessors,
+    sampler: createRuleBasedSampler(runtime),
+    instrumentations: getInstrumentations(config)
   });
   try {
-    await _.start();
-  } catch (c) {
-    console.warn("Telemetry start failed:", c);
-  }
-  return h;
-}, Vt = (t) => {
-  h == null || h.updateConfig(t);
-}, xt = (t) => (V.inject(x.active(), t), t), Ht = (t = fetch) => async (e, r) => {
-  const n = (r == null ? void 0 : r.headers) ?? (e instanceof Request ? e.headers : void 0), s = new Headers(n);
-  return V.inject(x.active(), s, {
-    set: (o, i, a) => {
-      o.set(i, a);
-    }
-  }), t(e, { ...r, headers: s });
-}, Dt = async () => {
-  _ && await _.shutdown();
+    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 {
-  rt as buildSamplingContextFromAttributes,
-  W as createIgnoreMatcher,
-  Ht as createPropagatingFetch,
-  K as createSpanNameMatcher,
-  ft as createTelemetryRuntime,
-  Z as defaultIgnoreConfig,
-  xt as injectTraceHeaders,
-  Et as loadTelemetryConfigFromEnv,
-  ot as matchSamplingRule,
-  st as resolveSamplingRatio,
-  v as resolveTelemetryConfig,
-  Dt as shutdownTelemetry,
-  Pt as startTelemetry,
-  Vt as updateTelemetryConfig
+  buildSamplingContextFromAttributes,
+  createIgnoreMatcher,
+  createPropagatingFetch,
+  createSpanNameMatcher,
+  createTelemetryRuntime,
+  defaultIgnoreConfig,
+  injectTraceHeaders,
+  loadTelemetryConfigFromEnv,
+  matchSamplingRule,
+  resolveSamplingRatio,
+  resolveTelemetryConfig,
+  shutdownTelemetry,
+  startTelemetry,
+  updateTelemetryConfig
 };