@getstrata/core 2.1.0 → 2.2.1

package/dist/entries/tracing/tracingMiddleware.js

@@ -26,6 +26,37 @@ function createAsyncContextStore(key) {
 }
 var init_asyncContextStore = () => {};
 
+// ../../src/core/tracing/tracingMiddleware.ts
+import { ROOT_CONTEXT, SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
+
+// ../../src/core/http/requestMetaContext.ts
+init_asyncContextStore();
+var requestMetaContext = createAsyncContextStore("@getstrata/requestMetaContext");
+function runWithRequestMeta(meta, callback) {
+  return requestMetaContext.run(meta, callback);
+}
+function currentRequestMeta() {
+  return requestMetaContext.getStore() ?? {
+    ipAddress: null,
+    userAgent: null
+  };
+}
+
+// ../../src/core/tracing/otel.ts
+import { context } from "@opentelemetry/api";
+import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
+import { W3CTraceContextPropagator } from "@opentelemetry/core";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import {
+  AlwaysOffSampler,
+  AlwaysOnSampler,
+  BatchSpanProcessor,
+  ParentBasedSampler,
+  TraceIdRatioBasedSampler
+} from "@opentelemetry/sdk-trace-base";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+
 // ../../src/core/runtime/appEnv.ts
 var NON_PRODUCTION_APP_ENVS = new Set(["local", "development", "dev", "test", "testing", "ci"]);
 function normalizeEnvValue(value) {
@@ -46,9 +77,6 @@ function envFlagEnabled(value) {
   return value === "true";
 }
 
-// ../../src/core/tracing/otel.ts
-import { randomBytes } from "crypto";
-
 // ../../src/core/runtime/appKeyPrefix.ts
 function appKeyPrefix() {
   return process.env.APP_KEY_PREFIX?.trim() || "strata";
@@ -115,422 +143,114 @@ function sdkClientClassName() {
   return fromName ? `${fromName}Client` : "AppClient";
 }
 
-// ../../src/core/security/safeUrl.ts
-import { lookup as dnsLookupImpl } from "dns/promises";
-import { BadRequestError } from "@getstrata/core/errors/http";
-var dnsLookup = dnsLookupImpl;
-var BLOCKED_HOSTNAMES = new Set([
-  "localhost",
-  "127.0.0.1",
-  "0.0.0.0",
-  "::1",
-  "metadata.google.internal"
-]);
-function parseCanonicalDottedDecimal(hostname) {
-  const parts = hostname.split(".");
-  if (parts.length !== 4) {
-    return null;
-  }
-  const octets = [];
-  for (const part of parts) {
-    if (!/^(0|[1-9]\d{0,2})$/u.test(part)) {
-      return null;
-    }
-    const value = Number.parseInt(part, 10);
-    if (!Number.isInteger(value) || value < 0 || value > 255) {
-      return null;
-    }
-    octets.push(value);
-  }
-  return octets;
-}
-function parseDottedIpv4(hostname) {
-  return parseCanonicalDottedDecimal(hostname);
-}
-function isBlockedIpv4Octets(octets) {
-  const [a = 0, b = 0] = octets;
-  if (a === 10 || a === 127 || a === 0) {
-    return true;
-  }
-  if (a === 169 && b === 254) {
-    return true;
-  }
-  if (a === 172 && b >= 16 && b <= 31) {
-    return true;
-  }
-  if (a === 192 && b === 168) {
-    return true;
-  }
-  if (a === 100 && b >= 64 && b <= 127) {
-    return true;
-  }
-  if (a === 198 && (b === 18 || b === 19)) {
-    return true;
-  }
-  return false;
-}
-function expandIpv6(hostname) {
-  const trimmed = hostname.trim().toLowerCase();
-  const unbracketed = trimmed.startsWith("[") && trimmed.endsWith("]") ? trimmed.slice(1, -1) : trimmed;
-  if (unbracketed.includes("%")) {
-    return null;
-  }
-  const mapped = unbracketed.match(/^::ffff:([0-9a-fx.]+)$/iu);
-  if (mapped?.[1]) {
-    const octets = parseDottedIpv4(mapped[1]);
-    if (!octets) {
-      return null;
-    }
-    return [
-      0,
-      0,
-      0,
-      0,
-      0,
-      65535,
-      octets[0] << 8 | octets[1],
-      octets[2] << 8 | octets[3]
-    ];
-  }
-  const halves = unbracketed.split("::");
-  if (halves.length > 2) {
-    return null;
-  }
-  const parseGroup = (part) => {
-    if (!/^[0-9a-f]{1,4}$/u.test(part)) {
-      return null;
-    }
-    return Number.parseInt(part, 16);
-  };
-  if (halves.length === 1) {
-    const groups = unbracketed.split(":");
-    if (groups.length !== 8) {
-      return null;
-    }
-    const values = groups.map(parseGroup);
-    return values.every((value) => value !== null) ? values : null;
-  }
-  const head = halves[0] ? halves[0].split(":").filter(Boolean) : [];
-  const tail = halves[1] ? halves[1].split(":").filter(Boolean) : [];
-  if (head.length + tail.length > 8) {
-    return null;
-  }
-  const values = [];
-  for (const part of head) {
-    const value = parseGroup(part);
-    if (value === null) {
-      return null;
-    }
-    values.push(value);
-  }
-  while (values.length < 8 - tail.length) {
-    values.push(0);
-  }
-  for (const part of tail) {
-    const value = parseGroup(part);
-    if (value === null) {
-      return null;
-    }
-    values.push(value);
-  }
-  return values.length === 8 ? values : null;
-}
-function isBlockedIpv6(hostname) {
-  const groups = expandIpv6(hostname);
-  if (!groups) {
-    return hostname.includes(":");
-  }
-  const first = groups[0] ?? 0;
-  const second = groups[1] ?? 0;
-  if (groups.every((group) => group === 0)) {
-    return true;
-  }
-  if (groups.slice(0, 7).every((group) => group === 0) && groups[7] === 1) {
-    return true;
-  }
-  if ((first & 65472) === 65152) {
-    return true;
-  }
-  if ((first & 65024) === 64512) {
-    return true;
-  }
-  if ((first & 65280) === 65280) {
-    return true;
-  }
-  if (first === 0 && second === 0 && groups[2] === 0 && groups[3] === 0 && groups[4] === 0 && groups[5] === 65535) {
-    const a = (groups[6] ?? 0) >> 8;
-    const b = (groups[6] ?? 0) & 255;
-    const c = (groups[7] ?? 0) >> 8;
-    const d = (groups[7] ?? 0) & 255;
-    return isBlockedIpv4Octets([a, b, c, d]);
-  }
-  return false;
-}
-function isBlockedHostname(hostname) {
-  const normalized = hostname.trim().toLowerCase();
-  if (normalized.length === 0) {
-    return true;
-  }
-  if (BLOCKED_HOSTNAMES.has(normalized)) {
-    return true;
-  }
-  if (normalized.endsWith(".local") || normalized.endsWith(".internal")) {
-    return true;
-  }
-  if (normalized.includes(":")) {
-    return isBlockedIpv6(normalized);
-  }
-  if (/^\d+$/u.test(normalized)) {
-    return true;
+// ../../src/core/tracing/otel.ts
+function numberOption(value, fallback, name, max = 1e6) {
+  const result = value ?? fallback;
+  if (!Number.isInteger(result) || result < 1 || result > max)
+    throw new TypeError(`Invalid tracing ${name}.`);
+  return result;
+}
+function ensureContextManager() {
+  const key = Symbol.for("@getstrata/otel-context-installed");
+  const state = globalThis;
+  if (state[key])
+    return;
+  const manager = new AsyncLocalStorageContextManager().enable();
+  if (!context.setGlobalContextManager(manager))
+    manager.disable();
+  state[key] = true;
+}
+function createTracingRuntime(options = {}) {
+  ensureContextManager();
+  const disabled = process.env.OTEL_SDK_DISABLED === "true";
+  const samplerName = options.sampleRatio === undefined ? process.env.OTEL_TRACES_SAMPLER ?? "parentbased_traceidratio" : "parentbased_traceidratio";
+  const rootName = samplerName.replace(/^parentbased_/, "");
+  if (!["always_on", "always_off", "traceidratio"].includes(rootName))
+    throw new TypeError("Unsupported tracing sampler.");
+  const ratio = options.sampleRatio ?? Number(process.env.OTEL_TRACES_SAMPLER_ARG ?? "1");
+  if (!Number.isFinite(ratio) || ratio < 0 || ratio > 1)
+    throw new TypeError("Invalid tracing sampleRatio.");
+  const rootSampler = rootName === "always_on" ? new AlwaysOnSampler : rootName === "always_off" ? new AlwaysOffSampler : new TraceIdRatioBasedSampler(ratio);
+  const sampler = disabled ? new AlwaysOffSampler : samplerName.startsWith("parentbased_") ? new ParentBasedSampler({ root: rootSampler }) : rootSampler;
+  const queueSize = numberOption(options.maxQueueSize, 2048, "maxQueueSize");
+  const batchSize = numberOption(options.maxExportBatchSize, Math.min(512, queueSize), "maxExportBatchSize", queueSize);
+  const timeout = numberOption(options.exportTimeoutMillis, 5000, "exportTimeoutMillis", 60000);
+  const delay = numberOption(options.scheduledDelayMillis, 5000, "scheduledDelayMillis", 60000);
+  let endpoint = options.endpoint ?? process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT?.trim();
+  if (!endpoint) {
+    const base = process.env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim();
+    if (base)
+      endpoint = base.endsWith("/v1/traces") ? base : `${base.replace(/\/$/, "")}/v1/traces`;
   }
-  if (normalized.includes(".")) {
-    const canonical = parseCanonicalDottedDecimal(normalized);
-    if (canonical) {
-      return isBlockedIpv4Octets(canonical);
-    }
-    if (/^[0-9a-fx.]+$/iu.test(normalized)) {
-      return true;
+  if (endpoint) {
+    let url;
+    try {
+      url = new URL(endpoint);
+    } catch {
+      throw new TypeError("Invalid tracing collector endpoint.");
     }
-  }
-  return false;
-}
-function productionSafeOutboundOptions(options) {
-  if (!isProductionEnv()) {
-    return options;
-  }
-  return { ...options, allowPrivate: false, resolveDns: true };
-}
-function assertSafeOutboundUrl(rawUrl, options = {}) {
-  const resolved = productionSafeOutboundOptions(options);
-  let parsed;
-  try {
-    parsed = new URL(rawUrl);
-  } catch {
-    throw new BadRequestError("Webhook URL is invalid.");
-  }
-  if (parsed.protocol !== "https:" && !(resolved.allowHttp && parsed.protocol === "http:")) {
-    throw new BadRequestError("Webhook URL must use HTTPS.");
-  }
-  if (parsed.username || parsed.password) {
-    throw new BadRequestError("Webhook URL must not include credentials.");
-  }
-  if (!resolved.allowPrivate && isBlockedHostname(parsed.hostname)) {
-    throw new BadRequestError("Webhook URL targets a blocked host.");
-  }
-  return parsed;
-}
-function isBlockedIpAddress(address) {
-  return isBlockedHostname(address.trim().toLowerCase());
-}
-function isLiteralIpHostname(hostname) {
-  return parseCanonicalDottedDecimal(hostname) !== null || expandIpv6(hostname) !== null;
-}
-function pinUrlToAddress(url, address) {
-  const pinned = new URL(url.toString());
-  const ipv6 = expandIpv6(address.replace(/^\[|\]$/gu, ""));
-  pinned.hostname = ipv6 ? `[${address.replace(/^\[|\]$/gu, "")}]` : address;
-  return pinned;
-}
-async function resolveSafeOutboundTarget(rawUrl, options = {}) {
-  const resolvedOptions = productionSafeOutboundOptions(options);
-  const parsed = assertSafeOutboundUrl(rawUrl, resolvedOptions);
-  if (resolvedOptions.resolveDns === false || resolvedOptions.allowPrivate) {
-    return { url: parsed, addresses: [] };
-  }
-  const hostname = parsed.hostname.trim().toLowerCase();
-  if (isLiteralIpHostname(hostname)) {
-    return { url: parsed, addresses: [hostname] };
-  }
-  let results;
-  try {
-    results = await dnsLookup(hostname, { all: true, verbatim: true });
-  } catch {
-    throw new BadRequestError("Webhook URL targets a blocked host.");
-  }
-  if (results.length === 0 || results.some((result) => isBlockedIpAddress(result.address))) {
-    throw new BadRequestError("Webhook URL targets a blocked host.");
-  }
-  return { url: parsed, addresses: results.map((result) => result.address) };
-}
-
-// ../../src/core/security/safeFetch.ts
-var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
-function untilAborted(work, signal) {
-  signal.throwIfAborted();
-  return new Promise((resolve, reject) => {
-    const onAbort = () => reject(signal.reason);
-    signal.addEventListener("abort", onAbort, { once: true });
-    work.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
-  });
-}
-function preserveResponseMetadata(response, original) {
-  Object.defineProperties(response, {
-    url: { value: original.url },
-    redirected: { value: original.redirected },
-    type: { value: original.type }
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash)
+      throw new TypeError("Invalid tracing collector endpoint.");
+  }
+  const exporter = disabled ? undefined : options.exporter ?? (endpoint ? new OTLPTraceExporter({ url: endpoint, timeoutMillis: timeout, concurrencyLimit: 1 }) : undefined);
+  const provider = new NodeTracerProvider({
+    resource: resourceFromAttributes({ "service.name": options.serviceName ?? otelServiceName() }),
+    sampler,
+    spanProcessors: exporter ? [
+      new BatchSpanProcessor(exporter, {
+        maxQueueSize: queueSize,
+        maxExportBatchSize: batchSize,
+        scheduledDelayMillis: delay,
+        exportTimeoutMillis: timeout
+      })
+    ] : [],
+    spanLimits: {
+      attributeCountLimit: 16,
+      attributeValueLengthLimit: 256,
+      eventCountLimit: 8,
+      linkCountLimit: 8
+    },
+    forceFlushTimeoutMillis: timeout
   });
-  const clone = response.clone.bind(response);
-  response.clone = () => preserveResponseMetadata(clone(), original);
-  return response;
-}
-function withBodyDeadline(response, signal, release) {
-  if (!response.body) {
-    release();
-    return response;
-  }
-  const reader = response.body.getReader();
-  let stopped = false;
-  let bodyController;
-  const stop = (reason, errorBody) => {
-    if (stopped)
-      return;
-    stopped = true;
-    release();
-    signal.removeEventListener("abort", onAbort);
-    if (errorBody)
-      bodyController.error(reason);
-    reader.cancel(reason).catch(() => {}).finally(() => reader.releaseLock());
+  let shutdown;
+  return {
+    tracer: provider.getTracer("@getstrata/http"),
+    propagator: new W3CTraceContextPropagator,
+    run: (parent, callback) => context.with(parent, callback),
+    forceFlush: () => provider.forceFlush(),
+    shutdown: () => shutdown ??= provider.shutdown()
   };
-  const onAbort = () => stop(signal.reason, true);
-  const body = new ReadableStream({
-    start(controller) {
-      bodyController = controller;
-      signal.addEventListener("abort", onAbort, { once: true });
-      if (signal.aborted)
-        onAbort();
-    },
-    async pull(controller) {
-      try {
-        const result = await untilAborted(reader.read(), signal);
-        if (stopped)
-          return;
-        if (result.done) {
-          stopped = true;
-          release();
-          signal.removeEventListener("abort", onAbort);
-          reader.releaseLock();
-          controller.close();
-        } else {
-          controller.enqueue(result.value);
-        }
-      } catch (error) {
-        stop(error, true);
-      }
-    },
-    cancel(reason) {
-      stop(reason, false);
-    }
-  }, { highWaterMark: 0 });
-  return preserveResponseMetadata(new Response(body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers
-  }), response);
 }
-async function safeFetch(input, init = {}, options = {}) {
-  init.signal?.throwIfAborted();
-  const timeoutMs = options.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-    throw new RangeError("safeFetch timeoutMs must be a positive finite number.");
-  }
-  const maxRedirects = options.maxRedirects ?? 0;
-  const urlOptions = {
-    allowHttp: options.allowHttp,
-    resolveDns: options.resolveDns ?? true,
-    allowPrivate: options.allowPrivate
-  };
-  const controller = new AbortController;
-  const forwardAbort = () => controller.abort(init.signal?.reason);
-  init.signal?.addEventListener("abort", forwardAbort, { once: true });
-  const timeout = setTimeout(() => controller.abort(new DOMException("The operation timed out.", "TimeoutError")), timeoutMs);
-  const release = () => {
-    clearTimeout(timeout);
-    init.signal?.removeEventListener("abort", forwardAbort);
-  };
-  try {
-    let current = await untilAborted(resolveSafeOutboundTarget(input, urlOptions), controller.signal);
-    let redirectCount = 0;
-    while (true) {
-      controller.signal.throwIfAborted();
-      const address = current.addresses[0];
-      const fetchUrl = address ? pinUrlToAddress(current.url, address).toString() : current.url.toString();
-      const headers = new Headers(init.headers);
-      if (address && !headers.has("host"))
-        headers.set("Host", current.url.host);
-      const fetchInit = {
-        ...init,
-        headers,
-        signal: controller.signal,
-        redirect: "manual"
-      };
-      if (address)
-        fetchInit.tls = { serverName: current.url.hostname };
-      const response = await untilAborted(fetch(fetchUrl, fetchInit), controller.signal);
-      if (response.status >= 300 && response.status < 400) {
-        const location = response.headers.get("location");
-        if (location && redirectCount < maxRedirects) {
-          if (response.body)
-            await untilAborted(response.body.cancel(), controller.signal);
-          current = await untilAborted(resolveSafeOutboundTarget(new URL(location, current.url).toString(), urlOptions), controller.signal);
-          redirectCount++;
-          continue;
-        }
+var runtimeKey = Symbol.for("@getstrata/otel-runtime");
+function runtimeState() {
+  const state = globalThis;
+  state[runtimeKey] ??= { owners: 0 };
+  return state[runtimeKey];
+}
+function getTracingRuntime() {
+  const state = runtimeState();
+  state.runtime ??= createTracingRuntime();
+  return state.runtime;
+}
+function acquireTracingRuntime() {
+  const state = runtimeState();
+  const runtime = getTracingRuntime();
+  state.owners++;
+  let released = false;
+  return {
+    flush: () => runtime.forceFlush(),
+    async release() {
+      if (released)
+        return;
+      released = true;
+      if (--state.owners === 0) {
+        if (state.runtime === runtime)
+          state.runtime = undefined;
+        await runtime.shutdown();
       }
-      return withBodyDeadline(response, controller.signal, release);
     }
-  } catch (error) {
-    controller.abort(error);
-    release();
-    throw error;
-  }
-}
-
-// ../../src/core/tracing/otel.ts
-function randomHex(bytes) {
-  return randomBytes(bytes).toString("hex");
-}
-function createSpan(input) {
-  const spanId = randomHex(8);
-  return {
-    traceId: input.traceId,
-    spanId,
-    name: input.name,
-    startTimeUnixNano: String(Math.floor(input.startedAt * 1e6)),
-    endTimeUnixNano: String(Math.floor(input.endedAt * 1e6)),
-    attributes: Object.entries(input.attributes ?? {}).map(([key, value]) => ({
-      key,
-      value: { stringValue: value }
-    })),
-    status: { code: 1 }
   };
 }
-async function exportOtelSpan(span) {
-  const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim();
-  if (!endpoint) {
-    return;
-  }
-  const serviceName = otelServiceName();
-  const url = endpoint.endsWith("/v1/traces") ? endpoint : `${endpoint.replace(/\/$/, "")}/v1/traces`;
-  await safeFetch(url, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({
-      resourceSpans: [
-        {
-          resource: {
-            attributes: [{ key: "service.name", value: { stringValue: serviceName } }]
-          },
-          scopeSpans: [{ spans: [span] }]
-        }
-      ]
-    })
-  }, {
-    allowHttp: !isProductionEnv(),
-    allowPrivate: !isProductionEnv(),
-    timeoutMs: 5000,
-    maxRedirects: 0
-  });
-}
 
 // ../../src/core/tracing/traceContext.ts
 init_asyncContextStore();
@@ -540,52 +260,64 @@ function runWithTraceContext(context, callback) {
 }
 
 // ../../src/core/tracing/tracingMiddleware.ts
-function readClientTraceId(request) {
-  if (!envFlagEnabled(process.env.APP_DEBUG)) {
-    return null;
-  }
-  const raw = request.headers.get("x-trace-id")?.trim() ?? "";
-  if (!raw) {
-    return null;
-  }
-  const compact = raw.replace(/-/g, "");
-  return /^[0-9a-f]{32}$/iu.test(compact) ? compact.toLowerCase() : null;
-}
-function createTracingMiddleware() {
+var headerGetter = {
+  keys: (headers) => [...headers.keys()],
+  get: (headers, key) => headers.get(key) ?? undefined
+};
+var methods = new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS",
+  "CONNECT",
+  "TRACE"
+]);
+function createTracingMiddleware(runtime) {
   return async (request, next) => {
-    const traceId = readClientTraceId(request) ?? crypto.randomUUID().replace(/-/g, "");
-    const spanId = crypto.randomUUID().replace(/-/g, "").slice(0, 16);
-    const startedAt = performance.now();
-    const path = new URL(request.url).pathname;
-    return await runWithTraceContext({ traceId, spanId }, async () => {
-      const response = await next();
-      const endedAt = performance.now();
-      const headers = new Headers(response.headers);
-      headers.set("x-trace-id", traceId);
-      headers.set("x-span-id", spanId);
-      headers.set("traceparent", `00-${traceId}-${spanId}-01`);
-      headers.set("server-timing", `app;dur=${(endedAt - startedAt).toFixed(2)}`);
-      exportOtelSpan(createSpan({
-        traceId,
-        name: `${request.method} ${path}`,
-        startedAt,
-        endedAt,
-        attributes: {
-          "http.method": request.method,
-          "http.route": path,
-          "http.status_code": String(response.status)
-        }
-      })).catch(() => {
-        return;
-      });
-      return new Response(response.body, {
-        status: response.status,
-        statusText: response.statusText,
-        headers
-      });
-    });
+    const telemetry = runtime ?? getTracingRuntime();
+    const method = methods.has(request.method) ? request.method : "_OTHER";
+    const route = currentRequestMeta().routeTemplate ?? "__unmatched__";
+    const parent = telemetry.propagator.extract(ROOT_CONTEXT, request.headers, headerGetter);
+    const span = telemetry.tracer.startSpan(`${method} ${route}`, {
+      kind: SpanKind.SERVER,
+      attributes: { "http.request.method": method, "http.route": route }
+    }, parent);
+    const identity = span.spanContext();
+    const started = performance.now();
+    return await telemetry.run(trace.setSpan(parent, span), () => runWithTraceContext({ traceId: identity.traceId, spanId: identity.spanId }, async () => {
+      try {
+        const response = await next();
+        span.setAttribute("http.response.status_code", response.status);
+        if (response.status >= 500)
+          span.setStatus({ code: SpanStatusCode.ERROR });
+        const headers = new Headers(response.headers);
+        headers.delete("tracestate");
+        headers.set("x-trace-id", identity.traceId);
+        headers.set("x-span-id", identity.spanId);
+        telemetry.propagator.inject(trace.setSpan(parent, span), headers, {
+          set: (carrier, key, value) => carrier.set(key, value)
+        });
+        headers.set("server-timing", `app;dur=${(performance.now() - started).toFixed(2)}`);
+        return new Response(response.body, {
+          status: response.status,
+          statusText: response.statusText,
+          headers
+        });
+      } catch (error) {
+        span.setStatus({ code: SpanStatusCode.ERROR });
+        throw error;
+      } finally {
+        span.end();
+      }
+    }));
   };
 }
 export {
-  createTracingMiddleware
+  acquireTracingRuntime,
+  createTracingMiddleware,
+  createTracingRuntime,
+  getTracingRuntime
 };