@elysia/opentelemetry 1.4.11 → 2.0.0-exp.0

package/dist/index.d.ts

@@ -1,6 +1,8 @@
-import { Elysia } from 'elysia';
-import { type ContextManager, type Context, type SpanOptions, type Span, type Attributes, TraceAPI, TracerProvider } from '@opentelemetry/api';
-import { NodeSDK } from '@opentelemetry/sdk-node';
+import { Elysia } from "elysia";
+import { Attributes, Context, ContextManager, Span, SpanOptions, TraceAPI, TracerProvider } from "@opentelemetry/api";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+
+//#region src/index.d.ts
 type OpenTeleMetryOptions = NonNullable<ConstructorParameters<typeof NodeSDK>[0]>;
 /**
  * Initialize OpenTelemetry SDK
@@ -8,63 +10,77 @@ type OpenTeleMetryOptions = NonNullable<ConstructorParameters<typeof NodeSDK>[0]
  * For best practice, you should be using preload OpenTelemetry SDK if possible
  * however, this is a simple way to initialize OpenTelemetry SDK
  */
-export interface ElysiaOpenTelemetryOptions extends OpenTeleMetryOptions {
-    contextManager?: ContextManager;
-    /**
-     * Optional function to determine whether a given request should be traced.
-     *
-     * @param req - The incoming request object to evaluate.
-     * @returns A boolean indicating whether tracing should be enabled for this request.
-     */
-    checkIfShouldTrace?: (req: Request) => boolean;
+interface ElysiaOpenTelemetryOptions extends OpenTeleMetryOptions {
+  contextManager?: ContextManager;
+  /**
+   * Optional function to determine whether a given request should be traced.
+   *
+   * @param req - The incoming request object to evaluate.
+   * @returns A boolean indicating whether tracing should be enabled for this request.
+   */
+  checkIfShouldTrace?: (req: Request) => boolean;
+  /**
+   * Redact `userinfo` and sensitive query values in `url.full` / `url.query`.
+   * Omitted: default redaction. `false`: record raw URLs (may leak secrets in query or credentials).
+   */
+  spanUrlRedaction?: false | {
+    stripCredentials?: boolean;
+    sensitiveQueryParams?: string[];
+  };
+  /**
+   * Record full request/response body content on spans.
+   * `true`: record both request and response bodies.
+   * `{ request: true }` or `{ response: true }`: record only one side.
+   * Default: `false` (no body content recorded).
+   */
+  recordBody?: boolean | {
+    request?: boolean;
+    response?: boolean;
+  };
+  /**
+   * HTTP header names (case-insensitive) to capture as span attributes.
+   * Use `"*"` in either list to capture all headers (useful for dev/debugging; may include sensitive values).
+   * Including `"cookie"` in `requestHeaders` also emits `http.request.cookie` when `context.cookie` exists.
+   * Default: none (no headers recorded).
+   */
+  headersToSpanAttributes?: {
+    request?: string[];
+    response?: string[];
+  };
 }
-export type ActiveSpanArgs<F extends (span: Span) => unknown = (span: Span) => unknown> = [name: string, fn: F] | [name: string, options: SpanOptions, fn: F] | [name: string, options: SpanOptions, context: Context, fn: F];
-export declare const shouldStartNodeSDK: (provider: TracerProvider) => boolean;
-export type Tracer = ReturnType<TraceAPI['getTracer']>;
-export type StartSpan = Tracer['startSpan'];
-export type StartActiveSpan = Tracer['startActiveSpan'];
-export declare const contextKeySpan: unique symbol;
-export declare const getTracer: () => ReturnType<TraceAPI["getTracer"]>;
-export declare const startSpan: (name: string, options?: SpanOptions, context?: Context) => Span;
-export declare const startActiveSpan: StartActiveSpan;
-export declare const record: {
-    <F extends (span: Span) => unknown>(name: string, fn: F): ReturnType<F>;
-    <F extends (span: Span) => unknown>(name: string, options: SpanOptions, fn: F): ReturnType<F>;
-    <F extends (span: Span) => unknown>(name: string, options: SpanOptions, context: Context, fn: F): ReturnType<F>;
+type ActiveSpanArgs<F extends (span: Span) => unknown = (span: Span) => unknown> = [name: string, fn: F] | [name: string, options: SpanOptions, fn: F] | [name: string, options: SpanOptions, context: Context, fn: F];
+declare const shouldStartNodeSDK: (provider: TracerProvider) => boolean;
+type Tracer = ReturnType<TraceAPI['getTracer']>;
+type StartSpan = Tracer['startSpan'];
+type StartActiveSpan = Tracer['startActiveSpan'];
+declare const contextKeySpan: unique symbol;
+declare const getTracer: () => ReturnType<TraceAPI["getTracer"]>;
+declare const startSpan: (name: string, options?: SpanOptions, context?: Context) => Span;
+declare const startActiveSpan: StartActiveSpan;
+declare const record: {
+  <F extends (span: Span) => unknown>(name: string, fn: F): ReturnType<F>;
+  <F extends (span: Span) => unknown>(name: string, options: SpanOptions, fn: F): ReturnType<F>;
+  <F extends (span: Span) => unknown>(name: string, options: SpanOptions, context: Context, fn: F): ReturnType<F>;
 };
-export declare const getCurrentSpan: () => Span | undefined;
+declare const getCurrentSpan: () => Span | undefined;
 /**
  * Set attributes to the current span
  *
  * @returns boolean - whether the attributes are set or not
  */
-export declare const setAttributes: (attributes: Attributes) => boolean;
-export declare const opentelemetry: ({ serviceName, instrumentations, contextManager, checkIfShouldTrace, ...options }?: ElysiaOpenTelemetryOptions) => Elysia<"", {
-    decorator: {};
-    store: {};
-    derive: {};
-    resolve: {};
-}, {
-    typebox: {};
-    error: {};
-}, {
-    schema: {};
-    standaloneSchema: {};
-    macro: {};
-    macroFn: {};
-    parser: {};
-    response: {};
-}, {}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-    standaloneSchema: {};
-    response: {};
-}>;
-export {};
+declare const setAttributes: (attributes: Attributes) => boolean;
+declare const opentelemetry: ({
+  serviceName,
+  instrumentations,
+  contextManager,
+  checkIfShouldTrace,
+  spanUrlRedaction,
+  recordBody,
+  headersToSpanAttributes,
+  ...options
+}?: ElysiaOpenTelemetryOptions) => Elysia<"", "local", import("elysia/dist/types").DefaultSingleton, {
+  typebox: {};
+  error: [];
+}, import("elysia/dist/types").DefaultMetadata, {}, import("elysia/dist/types").DefaultEphemeral, import("elysia/dist/types").DefaultEphemeral>;
+//#endregion
+export { ActiveSpanArgs, ElysiaOpenTelemetryOptions, StartActiveSpan, StartSpan, Tracer, contextKeySpan, getCurrentSpan, getTracer, opentelemetry, record, setAttributes, shouldStartNodeSDK, startActiveSpan, startSpan };

package/dist/index.js

@@ -0,0 +1,511 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let elysia = require("elysia");
+let _opentelemetry_api = require("@opentelemetry/api");
+let _opentelemetry_sdk_node = require("@opentelemetry/sdk-node");
+
+//#region src/index.ts
+const headerHasToJSON = typeof new Headers().toJSON === "function";
+const toHeaderNameSet = (names) => new Set((names ?? []).map((name) => name.toLowerCase()));
+const SENSITIVE_QUERY_KEYS = /* @__PURE__ */ new Set([
+	"token",
+	"access_token",
+	"refresh_token",
+	"id_token",
+	"password",
+	"passwd",
+	"pwd",
+	"secret",
+	"client_secret",
+	"api_key",
+	"apikey",
+	"api-key",
+	"authorization",
+	"credential",
+	"credentials",
+	"code",
+	"nonce"
+]);
+const parseNumericString = (message) => {
+	if (message.length < 16) {
+		if (message.length === 0) return null;
+		const length = Number(message);
+		if (Number.isNaN(length)) return null;
+		return length;
+	}
+	if (message.length === 16) {
+		const number = Number(message);
+		if (number.toString() !== message || message.trim().length === 0 || Number.isNaN(number)) return null;
+		return number;
+	}
+	return null;
+};
+const createActiveSpanHandler = (fn) => function(span) {
+	try {
+		const result = fn(span);
+		if (result instanceof Promise || typeof result?.then === "function") return Promise.resolve(result).then((value) => {
+			span.end();
+			return value;
+		}, (rejectResult) => {
+			span.setStatus({
+				code: _opentelemetry_api.SpanStatusCode.ERROR,
+				message: rejectResult instanceof Error ? rejectResult.message : JSON.stringify(rejectResult ?? "Unknown error")
+			});
+			span.recordException(rejectResult);
+			span.end();
+			throw rejectResult;
+		});
+		span.end();
+		return result;
+	} catch (error) {
+		const err = error;
+		span.setStatus({
+			code: _opentelemetry_api.SpanStatusCode.ERROR,
+			message: err?.message
+		});
+		span.recordException(err);
+		span.end();
+		throw error;
+	}
+};
+const createContext = (parent) => ({
+	getValue() {
+		return parent;
+	},
+	setValue() {
+		return _opentelemetry_api.context.active();
+	},
+	deleteValue() {
+		return _opentelemetry_api.context.active();
+	}
+});
+const serializeBody = (body) => {
+	if (body instanceof Uint8Array) return {
+		text: "",
+		size: body.length
+	};
+	if (body instanceof ArrayBuffer) return {
+		text: "",
+		size: body.byteLength
+	};
+	if (body instanceof Blob) return {
+		text: "",
+		size: body.size
+	};
+	let text;
+	try {
+		text = typeof body === "object" ? JSON.stringify(body) : String(body);
+	} catch {
+		text = "[Unserializable]";
+	}
+	return {
+		text,
+		size: text.length
+	};
+};
+const redactQueryString = (query, keys) => {
+	if (query === "" || keys.size === 0) return query;
+	let out = "";
+	let partStart = 0;
+	let keyEnd = -1;
+	for (let i = 0; i <= query.length; i++) {
+		const ch = i === query.length ? 38 : query.charCodeAt(i);
+		if (ch === 61 && keyEnd === -1) {
+			keyEnd = i;
+			continue;
+		}
+		if (ch !== 38) continue;
+		const partEnd = i;
+		const rawKeyEnd = keyEnd === -1 ? partEnd : keyEnd;
+		const rawKey = query.slice(partStart, rawKeyEnd);
+		if (out) out += "&";
+		out += keys.has(rawKey.toLowerCase()) ? rawKey + "=[REDACTED]" : query.slice(partStart, partEnd);
+		partStart = i + 1;
+		keyEnd = -1;
+	}
+	return out;
+};
+const shouldStartNodeSDK = (provider) => {
+	return provider instanceof _opentelemetry_api.ProxyTracerProvider && provider.getDelegateTracer("check") === void 0;
+};
+const contextKeySpan = Symbol.for("OpenTelemetry Context Key SPAN");
+const getTracer = () => {
+	const tracer = _opentelemetry_api.trace.getTracer("Elysia");
+	return {
+		...tracer,
+		startSpan(name, options, context) {
+			return tracer.startSpan(name, options, context);
+		},
+		startActiveSpan(...args) {
+			switch (args.length) {
+				case 2: return tracer.startActiveSpan(args[0], createActiveSpanHandler(args[1]));
+				case 3: return tracer.startActiveSpan(args[0], args[1], createActiveSpanHandler(args[2]));
+				case 4: return tracer.startActiveSpan(args[0], args[1], args[2], createActiveSpanHandler(args[3]));
+			}
+		}
+	};
+};
+const startSpan = (name, options, context) => {
+	return getTracer().startSpan(name, options, context);
+};
+const startActiveSpan = (...args) => {
+	const tracer = getTracer();
+	switch (args.length) {
+		case 2: return tracer.startActiveSpan(args[0], createActiveSpanHandler(args[1]));
+		case 3: return tracer.startActiveSpan(args[0], args[1], createActiveSpanHandler(args[2]));
+		case 4: return tracer.startActiveSpan(args[0], args[1], args[2], createActiveSpanHandler(args[3]));
+	}
+};
+const record = startActiveSpan;
+const getCurrentSpan = () => _opentelemetry_api.trace.getActiveSpan();
+/**
+* Set attributes to the current span
+*
+* @returns boolean - whether the attributes are set or not
+*/
+const setAttributes = (attributes) => !!getCurrentSpan()?.setAttributes(attributes);
+const opentelemetry = ({ serviceName = "Elysia", instrumentations, contextManager, checkIfShouldTrace, spanUrlRedaction, recordBody, headersToSpanAttributes, ...options } = {}) => {
+	const spanRequestHeaderSet = toHeaderNameSet(headersToSpanAttributes?.request);
+	const spanResponseHeaderSet = toHeaderNameSet(headersToSpanAttributes?.response);
+	const requestHeaderWildcard = spanRequestHeaderSet.has("*");
+	const responseHeaderWildcard = spanResponseHeaderSet.has("*");
+	const recordRequestBody = recordBody === true || recordBody && recordBody.request || false;
+	const recordResponseBody = recordBody === true || recordBody && recordBody.response || false;
+	const urlRedactOpts = spanUrlRedaction === false ? null : spanUrlRedaction ?? {};
+	const sensitiveKeys = urlRedactOpts ? /* @__PURE__ */ new Set([...SENSITIVE_QUERY_KEYS, ...(urlRedactOpts.sensitiveQueryParams ?? []).map((k) => k.toLowerCase())]) : void 0;
+	const stripCreds = urlRedactOpts?.stripCredentials !== false;
+	let tracer = _opentelemetry_api.trace.getTracer(serviceName);
+	if (shouldStartNodeSDK(_opentelemetry_api.trace.getTracerProvider())) {
+		new _opentelemetry_sdk_node.NodeSDK({
+			...options,
+			serviceName,
+			instrumentations
+		}).start();
+		tracer = _opentelemetry_api.trace.getTracer(serviceName);
+	}
+	if (!_opentelemetry_api.context._getContextManager?.() && contextManager) try {
+		contextManager.enable();
+		_opentelemetry_api.context.setGlobalContextManager(contextManager);
+	} catch {}
+	const httpServerDuration = _opentelemetry_api.metrics.getMeter(serviceName).createHistogram("http.server.request.duration", {
+		description: "Duration of HTTP server requests.",
+		unit: "s",
+		advice: { explicitBucketBoundaries: [
+			.005,
+			.01,
+			.025,
+			.05,
+			.075,
+			.1,
+			.25,
+			.5,
+			.75,
+			1,
+			2.5,
+			5,
+			7.5,
+			10,
+			30,
+			60,
+			120,
+			300,
+			600,
+			900,
+			1800
+		] }
+	});
+	return new elysia.Elysia({ name: "@elysia/opentelemetry" }).wrap((fn) => {
+		return (request) => {
+			if (!(checkIfShouldTrace ? checkIfShouldTrace(request) : true)) return fn(request);
+			const headers = headerHasToJSON ? request.headers.toJSON() : Object.fromEntries(request.headers.entries());
+			const ctx = _opentelemetry_api.propagation.extract(_opentelemetry_api.context.active(), headers);
+			return tracer.startActiveSpan("Root", { kind: _opentelemetry_api.SpanKind.SERVER }, ctx, (rootSpan) => {
+				const spanContext = _opentelemetry_api.trace.setSpan(ctx, rootSpan);
+				return _opentelemetry_api.context.with(spanContext, () => fn(request));
+			});
+		};
+	}).trace("global", ({ id, onRequest, onParse, onTransform, onBeforeHandle, onHandle, onAfterHandle, onError, onAfterResponse, onMapResponse, context, context: { path, request: { method } } }) => {
+		const rootSpan = _opentelemetry_api.trace.getActiveSpan();
+		if (!rootSpan) return;
+		function setParent(span) {
+			if (span.ended) return;
+			if (rootSpan.ended) return void span.end();
+			const newContext = _opentelemetry_api.trace.setSpan(_opentelemetry_api.context.active(), span);
+			_opentelemetry_api.context.active()._currentContext?.set(contextKeySpan, newContext.getValue(contextKeySpan));
+		}
+		function inspect(name) {
+			return function inspect({ onEvent, total, onStop }) {
+				if (total === 0 || rootSpan.ended) return;
+				tracer.startActiveSpan(name, {}, createContext(rootSpan), (event) => {
+					if (rootSpan.ended) return;
+					onEvent(({ name, onStop }) => {
+						const useChildSpan = total > 1;
+						let span;
+						if (useChildSpan) {
+							span = tracer.startSpan(name, {}, createContext(event));
+							setParent(span);
+						} else {
+							setParent(event);
+							span = event;
+						}
+						onStop(({ error }) => {
+							setParent(rootSpan);
+							if (span.ended || rootSpan.ended) return;
+							if (error) span.setAttributes({
+								"error.type": error.constructor?.name ?? error.name,
+								"error.stack": error.stack
+							});
+							if (useChildSpan) span.end();
+						});
+					});
+					onStop(() => {
+						setParent(rootSpan);
+						if (event.ended) return;
+						event.end();
+					});
+				});
+			};
+		}
+		const rawUrl = context.request.url;
+		const qi = context.qi;
+		let urlQuery = qi !== void 0 && qi !== -1 ? rawUrl.slice(qi + 1) : void 0;
+		let urlFull = rawUrl;
+		if (urlRedactOpts) {
+			if (urlQuery !== void 0) {
+				urlQuery = redactQueryString(urlQuery, sensitiveKeys);
+				urlFull = `${rawUrl.slice(0, qi)}?${urlQuery}`;
+			}
+			if (stripCreds && urlFull.indexOf("@") > 0) try {
+				const u = new URL(urlFull);
+				if (u.username || u.password) {
+					u.username = "";
+					u.password = "";
+					urlFull = u.href;
+				}
+			} catch {}
+		}
+		const attributes = Object.assign(Object.create(null), {
+			"http.request.id": id,
+			"http.request.method": method,
+			"url.path": path,
+			"url.full": urlFull
+		});
+		if (urlQuery !== void 0) attributes["url.query"] = urlQuery;
+		const protocolSeparator = urlFull.indexOf("://");
+		if (protocolSeparator > 0) attributes["url.scheme"] = urlFull.slice(0, protocolSeparator);
+		const requestStartTime = performance.now();
+		let durationRecorded = false;
+		const recordDuration = () => {
+			if (durationRecorded) return;
+			durationRecorded = true;
+			const durationS = (performance.now() - requestStartTime) / 1e3;
+			const statusCode = attributes["http.response.status_code"];
+			const metricAttributes = {
+				"http.request.method": attributes["http.request.method"] ?? method,
+				"url.scheme": attributes["url.scheme"],
+				"http.response.status_code": statusCode,
+				"http.route": attributes["http.route"]
+			};
+			if (typeof statusCode === "number" && statusCode >= 500) metricAttributes["error.type"] = String(statusCode);
+			httpServerDuration.record(durationS, metricAttributes);
+		};
+		onRequest(inspect("Request"));
+		onParse(inspect("Parse"));
+		onTransform(inspect("Transform"));
+		onBeforeHandle(inspect("BeforeHandle"));
+		onHandle(({ onStop }) => {
+			const span = tracer.startSpan("Handle", {}, createContext(rootSpan));
+			setParent(span);
+			onStop(({ error }) => {
+				setParent(rootSpan);
+				if (span.ended || rootSpan.ended) return;
+				if (error) {
+					span.recordException(error);
+					rootSpan.recordException(error);
+				}
+				span.end();
+			});
+		});
+		onAfterHandle(inspect("AfterHandle"));
+		onError((event) => {
+			inspect("Error")(event);
+			event.onStop(({ error }) => {
+				setParent(rootSpan);
+				if (rootSpan.ended) return;
+				{
+					let status = context.set.status;
+					if (typeof status === "string") status = elysia.StatusMap[status];
+					else if (typeof status !== "number" && typeof error?.status === "number") status = error.status;
+					if (typeof status === "number") {
+						attributes["http.response.status_code"] = status;
+						if (status >= 500) rootSpan.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
+					}
+					rootSpan.setAttributes(attributes);
+				}
+			});
+		});
+		onMapResponse(inspect("MapResponse"));
+		onTransform(() => {
+			const { cookie, request, route, path } = context;
+			const routeName = route ?? path;
+			rootSpan.updateName(`${method} ${routeName}`);
+			attributes["http.route"] = routeName;
+			/**
+			* ? Caution: This is not a standard way to get content-length
+			*
+			* As state in OpenTelemetry specification:
+			* The size of the request payload body in bytes.
+			* This is the number of bytes transferred excluding headers and is often,
+			* but not always, present as the Content-Length header.
+			* For requests using transport encoding, this should be the compressed size.
+			**/
+			const contentLength = request.headers.get("content-length");
+			if (contentLength) {
+				const number = parseNumericString(contentLength);
+				if (number !== null) attributes["http.request_content_length"] = number;
+			}
+			const userAgent = request.headers.get("User-Agent");
+			if (userAgent) attributes["user_agent.original"] = userAgent;
+			const server = context.server;
+			if (server) {
+				attributes["server.port"] = server.port ?? 80;
+				attributes["server.address"] = server.url.hostname;
+			}
+			let headers;
+			{
+				let hasHeaders;
+				let _headers;
+				if (context.headers) {
+					hasHeaders = true;
+					headers = context.headers;
+					_headers = Object.entries(context.headers);
+				} else if (hasHeaders = headerHasToJSON) {
+					headers = request.headers.toJSON();
+					_headers = Object.entries(headers);
+				} else {
+					headers = {};
+					_headers = request.headers.entries();
+				}
+				for (let [key, value] of _headers) {
+					key = key.toLowerCase();
+					if (hasHeaders) {
+						if (!requestHeaderWildcard && !spanRequestHeaderSet.has(key)) continue;
+						if (typeof value === "object") attributes[`http.request.header.${key}`] = JSON.stringify(value);
+						else if (value !== void 0) attributes[`http.request.header.${key}`] = value;
+						continue;
+					}
+					if (typeof value === "object") {
+						const serialized = JSON.stringify(value);
+						headers[key] = serialized;
+						if (requestHeaderWildcard || spanRequestHeaderSet.has(key)) attributes[`http.request.header.${key}`] = serialized;
+					} else if (value !== void 0) {
+						headers[key] = value;
+						if (requestHeaderWildcard || spanRequestHeaderSet.has(key)) attributes[`http.request.header.${key}`] = value;
+					}
+				}
+			}
+			{
+				let headers;
+				if (context.set.headers instanceof Headers) if (headerHasToJSON) headers = Object.entries(context.set.headers.toJSON());
+				else headers = context.set.headers.entries();
+				else headers = Object.entries(context.set.headers);
+				for (let [key, value] of headers) {
+					key = key.toLowerCase();
+					if (!responseHeaderWildcard && !spanResponseHeaderSet.has(key)) continue;
+					if (typeof value === "object") attributes[`http.response.header.${key}`] = JSON.stringify(value);
+					else attributes[`http.response.header.${key}`] = value;
+				}
+			}
+			if (context.ip) attributes["client.address"] = context.ip;
+			else {
+				const ip = headers["true-client-ip"] ?? headers["cf-connection-ip"] ?? headers["x-forwarded-for"] ?? headers["x-real-ip"] ?? server?.requestIP(request);
+				if (ip) attributes["client.address"] = typeof ip === "string" ? ip : ip.address ?? ip.toString();
+			}
+			if ((requestHeaderWildcard || spanRequestHeaderSet.has("cookie")) && cookie) {
+				const _cookie = {};
+				for (const [key, { value }] of Object.entries(cookie)) _cookie[key] = JSON.stringify(value);
+				attributes["http.request.cookie"] = JSON.stringify(_cookie);
+			}
+			rootSpan.setAttributes(attributes);
+		});
+		onParse(() => {
+			const body = context.body;
+			if (body === void 0 || body === null || !recordRequestBody) return;
+			const { text, size } = serializeBody(body);
+			if (text) attributes["http.request.body"] = text;
+			attributes["http.request.body.size"] = size;
+		});
+		onMapResponse(() => {
+			const body = context.body;
+			if (body !== void 0 && body !== null && recordRequestBody) {
+				const { text, size } = serializeBody(body);
+				if (text) attributes["http.request.body"] = text;
+				attributes["http.request.body.size"] = size;
+			}
+			{
+				let status = context.set.status ?? 200;
+				if (typeof status === "string") status = elysia.StatusMap[status] ?? 200;
+				attributes["http.response.status_code"] = status;
+			}
+			const response = context.responseValue;
+			if (response !== void 0 && recordResponseBody) {
+				const { text, size } = serializeBody(response);
+				if (text) attributes["http.response.body"] = text;
+				attributes["http.response.body.size"] = size;
+			}
+			if (!rootSpan.ended) {
+				const statusCode = attributes["http.response.status_code"];
+				if (typeof statusCode === "number" && statusCode >= 500) rootSpan.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
+				rootSpan.setAttributes(attributes);
+			}
+		});
+		onAfterResponse((event) => {
+			inspect("AfterResponse")(event);
+			{
+				let status = context.set.status ?? 200;
+				if (typeof status === "string") status = elysia.StatusMap[status] ?? 200;
+				attributes["http.response.status_code"] = status;
+			}
+			const body = context.body;
+			if (body !== void 0 && body !== null && recordRequestBody) {
+				const { text, size } = serializeBody(body);
+				if (text) attributes["http.request.body"] = text;
+				attributes["http.request.body.size"] = size;
+			}
+			if (!rootSpan.ended) {
+				const statusCode = attributes["http.response.status_code"];
+				if (typeof statusCode === "number" && statusCode >= 500) rootSpan.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
+				rootSpan.setAttributes(attributes);
+			}
+			event.onStop(() => {
+				setParent(rootSpan);
+				if (rootSpan.ended) return;
+				if (!rootSpan.ended) {
+					recordDuration();
+					rootSpan.end();
+				}
+			});
+		});
+		context.request.signal.addEventListener("abort", () => {
+			const active = _opentelemetry_api.trace.getActiveSpan();
+			if (active && !active.ended) active.end();
+			if (rootSpan.ended) return;
+			rootSpan.setStatus({
+				code: _opentelemetry_api.SpanStatusCode.ERROR,
+				message: "Request aborted"
+			});
+			recordDuration();
+			rootSpan.end();
+		});
+	});
+};
+
+//#endregion
+exports.contextKeySpan = contextKeySpan;
+exports.getCurrentSpan = getCurrentSpan;
+exports.getTracer = getTracer;
+exports.opentelemetry = opentelemetry;
+exports.record = record;
+exports.setAttributes = setAttributes;
+exports.shouldStartNodeSDK = shouldStartNodeSDK;
+exports.startActiveSpan = startActiveSpan;
+exports.startSpan = startSpan;