@pingops/core 0.1.3 → 0.2.1

package/dist/index.d.mts

@@ -29,9 +29,10 @@ interface SpanPayload {
   };
 }
 /**
- * Attributes to propagate to HTTP spans
+ * Attributes to propagate to spans (e.g. when starting a trace with startTrace).
  */
-interface WrapHttpAttributes {
+interface PingopsTraceAttributes {
+  traceId?: string;
   userId?: string;
   sessionId?: string;
   tags?: string[];
@@ -53,7 +54,10 @@ interface WrapHttpAttributes {
  * Checks if a span is eligible for capture based on span kind and attributes.
  * A span is eligible if:
  * 1. span.kind === SpanKind.CLIENT
- * 2. AND has HTTP attributes (http.method, http.url, or server.address)
+ * 2. AND has HTTP attributes
+ *    - method: http.method or http.request.method
+ *    - url: http.url or url.full
+ *    - host: server.address
  *    OR has GenAI attributes (gen_ai.system, gen_ai.operation.name)
  */
 declare function isSpanEligible(span: ReadableSpan): boolean;
@@ -177,12 +181,54 @@ declare function extractHeadersFromAttributes(attributes: Record<string, unknown
  */
 declare function normalizeHeaders(headers: unknown): Record<string, string | string[] | undefined>;
 //#endregion
+//#region src/filtering/body-decoder.d.ts
+/**
+ * Minimal body handling: buffer to string for span attributes.
+ * No decompression or truncation; for compressed responses the instrumentation
+ * sends base64 + content-encoding so the backend can decompress.
+ */
+/** Span attribute for response content-encoding when body is sent as base64. */
+declare const HTTP_RESPONSE_CONTENT_ENCODING = "http.response.content_encoding";
+/**
+ * Returns true if the content-encoding header indicates a compressed body
+ * (gzip, br, deflate, x-gzip, x-deflate). Used to decide whether to send
+ * body as base64 + content-encoding for backend decompression.
+ */
+declare function isCompressedContentEncoding(headerValue: unknown): boolean;
+/**
+ * Converts a buffer to a UTF-8 string for use as request/response body on spans.
+ * Returns null for null, undefined, or empty buffer.
+ */
+declare function bufferToBodyString(buffer: Buffer | null | undefined): string | null;
+//#endregion
 //#region src/utils/span-extractor.d.ts
 /**
  * Extracts structured payload from a span
  */
 declare function extractSpanPayload(span: ReadableSpan, domainAllowList?: DomainRule[], globalHeadersAllowList?: string[], globalHeadersDenyList?: string[], globalCaptureRequestBody?: boolean, globalCaptureResponseBody?: boolean, headerRedaction?: HeaderRedactionConfig): SpanPayload | null;
 //#endregion
+//#region src/utils/http-attributes.d.ts
+/**
+ * Helpers for reading HTTP-related span attributes across legacy and modern
+ * OpenTelemetry semantic conventions.
+ */
+type SpanAttributes = Record<string, unknown>;
+/**
+ * Returns true when either legacy or modern HTTP method attribute is present.
+ */
+declare function hasHttpMethodAttribute(attributes: SpanAttributes): boolean;
+/**
+ * Returns true when either legacy or modern HTTP URL attribute is present.
+ */
+declare function hasHttpUrlAttribute(attributes: SpanAttributes): boolean;
+/**
+ * Extracts URL from known HTTP attributes with support for legacy + modern keys.
+ *
+ * If no explicit URL exists but server.address is available, falls back to a
+ * synthetic HTTPS URL for downstream domain filtering.
+ */
+declare function getHttpUrlFromAttributes(attributes: SpanAttributes): string | undefined;
+//#endregion
 //#region src/utils/context-extractor.d.ts
 /**
  * Extracts propagated attributes from the given context and returns them
@@ -220,11 +266,10 @@ declare function createLogger(prefix: string): Logger;
  * OpenTelemetry context keys for PingOps
  */
 /**
- * Context key for enabling HTTP instrumentation.
- * When set to true, HTTP requests will be automatically instrumented.
- * This allows wrapHttp to control which HTTP calls are captured.
+ * Context key for trace ID attribute.
+ * Used to propagate trace identifier to all spans in the context.
  */
-declare const PINGOPS_HTTP_ENABLED: symbol;
+declare const PINGOPS_TRACE_ID: symbol;
 /**
  * Context key for user ID attribute.
  * Used to propagate user identifier to all spans in the context.
@@ -248,58 +293,28 @@ declare const PINGOPS_METADATA: symbol;
 /**
  * Context key for capturing request body.
  * When set, controls whether request bodies should be captured for HTTP spans.
- * This allows wrapHttp to control body capture per-request.
  */
 declare const PINGOPS_CAPTURE_REQUEST_BODY: symbol;
 /**
  * Context key for capturing response body.
  * When set, controls whether response bodies should be captured for HTTP spans.
- * This allows wrapHttp to control body capture per-request.
  */
 declare const PINGOPS_CAPTURE_RESPONSE_BODY: symbol;
 //#endregion
-//#region src/wrap-http.d.ts
+//#region src/trace-id.d.ts
 /**
- * Options for wrapHttp function
+ * Deterministic and random trace ID generation for PingOps
  */
-interface WrapHttpOptions {
-  attributes?: WrapHttpAttributes;
-  /**
-   * Callback to check if SDK is initialized.
-   * Required to determine if global instrumentation is enabled.
-   */
-  checkInitialized: () => boolean;
-  /**
-   * Callback to check if global instrumentation is enabled.
-   * Required to determine instrumentation behavior.
-   */
-  isGlobalInstrumentationEnabled: () => boolean;
-  /**
-   * Optional callback to ensure SDK is initialized (auto-initialization).
-   * If not provided, wrapHttp will try to auto-initialize from environment variables.
-   */
-  ensureInitialized?: () => Promise<void>;
-}
 /**
- * Wraps a function to set attributes on HTTP spans created within the wrapped block.
- *
- * This function sets attributes (userId, sessionId, tags, metadata) in the OpenTelemetry
- * context, which are automatically propagated to all spans created within the wrapped function.
- *
- * Instrumentation behavior:
- * - If `initializePingops` was called: All HTTP requests are instrumented by default.
- *   `wrapHttp` only adds attributes to spans created within the wrapped block.
- * - If `initializePingops` was NOT called: Only HTTP requests within `wrapHttp` blocks
- *   are instrumented. Requests outside `wrapHttp` are not instrumented.
- *
- * Note: This is the low-level API. For a simpler API with automatic setup,
- * use `wrapHttp` from `@pingops/sdk` instead.
- *
- * @param options - Options including attributes and required callbacks
- * @param fn - Function to execute within the attribute context
- * @returns The result of the function
+ * Converts a Uint8Array to a lowercase hex string.
+ */
+declare function uint8ArrayToHex(bytes: Uint8Array): string;
+/**
+ * Creates a trace ID (32 hex chars).
+ * - If `seed` is provided: deterministic via SHA-256 of the seed (first 32 hex chars).
+ * - Otherwise: random 16 bytes as 32 hex chars.
  */
-declare function wrapHttp<T>(options: WrapHttpOptions, fn: () => T | Promise<T>): T | Promise<T>;
+declare function createTraceId(seed?: string): Promise<string>;
 //#endregion
-export { DEFAULT_REDACTION_CONFIG, DEFAULT_SENSITIVE_HEADER_PATTERNS, DomainRule, HeaderRedactionConfig, HeaderRedactionStrategy, LogLevel, Logger, PINGOPS_CAPTURE_REQUEST_BODY, PINGOPS_CAPTURE_RESPONSE_BODY, PINGOPS_HTTP_ENABLED, PINGOPS_METADATA, PINGOPS_SESSION_ID, PINGOPS_TAGS, PINGOPS_USER_ID, SpanPayload, WrapHttpAttributes, WrapHttpOptions, createLogger, extractHeadersFromAttributes, extractSpanPayload, filterHeaders, getPropagatedAttributesFromContext, isSensitiveHeader, isSpanEligible, normalizeHeaders, redactHeaderValue, shouldCaptureSpan, wrapHttp };
+export { DEFAULT_REDACTION_CONFIG, DEFAULT_SENSITIVE_HEADER_PATTERNS, DomainRule, HTTP_RESPONSE_CONTENT_ENCODING, HeaderRedactionConfig, HeaderRedactionStrategy, LogLevel, Logger, PINGOPS_CAPTURE_REQUEST_BODY, PINGOPS_CAPTURE_RESPONSE_BODY, PINGOPS_METADATA, PINGOPS_SESSION_ID, PINGOPS_TAGS, PINGOPS_TRACE_ID, PINGOPS_USER_ID, PingopsTraceAttributes, SpanPayload, bufferToBodyString, createLogger, createTraceId, extractHeadersFromAttributes, extractSpanPayload, filterHeaders, getHttpUrlFromAttributes, getPropagatedAttributesFromContext, hasHttpMethodAttribute, hasHttpUrlAttribute, isCompressedContentEncoding, isSensitiveHeader, isSpanEligible, normalizeHeaders, redactHeaderValue, shouldCaptureSpan, uint8ArrayToHex };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/filtering/span-filter.ts","../src/filtering/domain-filter.ts","../src/filtering/sensitive-headers.ts","../src/filtering/header-filter.ts","../src/utils/span-extractor.ts","../src/utils/context-extractor.ts","../src/logger.ts","../src/context-keys.ts","../src/wrap-http.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/filtering/span-filter.ts","../src/filtering/domain-filter.ts","../src/filtering/sensitive-headers.ts","../src/filtering/header-filter.ts","../src/filtering/body-decoder.ts","../src/utils/span-extractor.ts","../src/utils/http-attributes.ts","../src/utils/context-extractor.ts","../src/logger.ts","../src/context-keys.ts","../src/trace-id.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { SpanKind, context, createContextKey } from "@opentelemetry/api";
+import { SpanKind, createContextKey } from "@opentelemetry/api";
 
 //#region src/logger.ts
 /**
@@ -28,6 +28,35 @@ function createLogger(prefix) {
 	};
 }
 
+//#endregion
+//#region src/utils/http-attributes.ts
+/**
+* Returns true when either legacy or modern HTTP method attribute is present.
+*/
+function hasHttpMethodAttribute(attributes) {
+	return attributes["http.method"] !== void 0 || attributes["http.request.method"] !== void 0;
+}
+/**
+* Returns true when either legacy or modern HTTP URL attribute is present.
+*/
+function hasHttpUrlAttribute(attributes) {
+	return attributes["http.url"] !== void 0 || attributes["url.full"] !== void 0;
+}
+/**
+* Extracts URL from known HTTP attributes with support for legacy + modern keys.
+*
+* If no explicit URL exists but server.address is available, falls back to a
+* synthetic HTTPS URL for downstream domain filtering.
+*/
+function getHttpUrlFromAttributes(attributes) {
+	const legacyUrl = attributes["http.url"];
+	if (typeof legacyUrl === "string" && legacyUrl.length > 0) return legacyUrl;
+	const modernUrl = attributes["url.full"];
+	if (typeof modernUrl === "string" && modernUrl.length > 0) return modernUrl;
+	const serverAddress = attributes["server.address"];
+	if (typeof serverAddress === "string" && serverAddress.length > 0) return `https://${serverAddress}`;
+}
+
 //#endregion
 //#region src/filtering/span-filter.ts
 /**
@@ -38,7 +67,10 @@ const log$2 = createLogger("[PingOps SpanFilter]");
 * Checks if a span is eligible for capture based on span kind and attributes.
 * A span is eligible if:
 * 1. span.kind === SpanKind.CLIENT
-* 2. AND has HTTP attributes (http.method, http.url, or server.address)
+* 2. AND has HTTP attributes
+*    - method: http.method or http.request.method
+*    - url: http.url or url.full
+*    - host: server.address
 *    OR has GenAI attributes (gen_ai.system, gen_ai.operation.name)
 */
 function isSpanEligible(span) {
@@ -56,8 +88,8 @@ function isSpanEligible(span) {
 		return false;
 	}
 	const attributes = span.attributes;
-	const hasHttpMethod = attributes["http.method"] !== void 0;
-	const hasHttpUrl = attributes["http.url"] !== void 0;
+	const hasHttpMethod = hasHttpMethodAttribute(attributes);
+	const hasHttpUrl = hasHttpUrlAttribute(attributes);
 	const hasServerAddress = attributes["server.address"] !== void 0;
 	const isEligible = hasHttpMethod || hasHttpUrl || hasServerAddress;
 	log$2.debug("Span eligibility check result", {
@@ -66,6 +98,10 @@ function isSpanEligible(span) {
 		httpAttributes: {
 			hasMethod: hasHttpMethod,
 			hasUrl: hasHttpUrl,
+			hasLegacyMethod: attributes["http.method"] !== void 0,
+			hasModernMethod: attributes["http.request.method"] !== void 0,
+			hasLegacyUrl: attributes["http.url"] !== void 0,
+			hasModernUrl: attributes["url.full"] !== void 0,
 			hasServerAddress
 		}
 	});
@@ -367,6 +403,10 @@ function redactSingleValue(value, config) {
 * Header filtering logic - applies allow/deny list rules and redaction
 */
 const log = createLogger("[PingOps HeaderFilter]");
+function toHeaderString(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
+}
 /**
 * Normalizes header name to lowercase for case-insensitive matching
 */
@@ -528,7 +568,8 @@ function extractHeadersFromAttributes(attributes, headerPrefix) {
 	if (directKeyValueHeaders.length > 0) for (const { key, headerName } of directKeyValueHeaders) {
 		const headerValue = attributes[key];
 		if (headerValue !== void 0 && headerValue !== null) {
-			const stringValue = typeof headerValue === "string" ? headerValue : String(headerValue);
+			const stringValue = toHeaderString(headerValue);
+			if (stringValue === void 0) continue;
 			const normalizedName = headerName.toLowerCase();
 			const existingKey = Object.keys(headerMap).find((k) => k.toLowerCase() === normalizedName);
 			if (existingKey) {
@@ -552,6 +593,13 @@ function normalizeHeaders(headers) {
 	const result = {};
 	if (!headers) return result;
 	try {
+		if (Array.isArray(headers)) {
+			for (let i = 0; i < headers.length; i += 2) if (i + 1 < headers.length) {
+				const key = String(headers[i]);
+				result[key] = headers[i + 1];
+			}
+			return result;
+		}
 		if (isHeadersLike(headers)) {
 			for (const [key, value] of headers.entries()) if (result[key]) {
 				const existing = result[key];
@@ -563,17 +611,57 @@ function normalizeHeaders(headers) {
 			for (const [key, value] of Object.entries(headers)) if (!/^\d+$/.test(key)) result[key] = value;
 			return result;
 		}
-		if (Array.isArray(headers)) {
-			for (let i = 0; i < headers.length; i += 2) if (i + 1 < headers.length) {
-				const key = String(headers[i]);
-				result[key] = headers[i + 1];
-			}
-			return result;
-		}
 	} catch {}
 	return result;
 }
 
+//#endregion
+//#region src/filtering/body-decoder.ts
+/**
+* Minimal body handling: buffer to string for span attributes.
+* No decompression or truncation; for compressed responses the instrumentation
+* sends base64 + content-encoding so the backend can decompress.
+*/
+/** Span attribute for response content-encoding when body is sent as base64. */
+const HTTP_RESPONSE_CONTENT_ENCODING = "http.response.content_encoding";
+const COMPRESSED_ENCODINGS = new Set([
+	"gzip",
+	"br",
+	"deflate",
+	"x-gzip",
+	"x-deflate"
+]);
+function safeStringify(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
+}
+function normalizeHeaderValue(v) {
+	if (v == null) return void 0;
+	if (Array.isArray(v)) return v.map((item) => safeStringify(item)).filter((item) => item !== void 0).join(", ").trim() || void 0;
+	const s = safeStringify(v);
+	if (!s) return void 0;
+	return s.trim() || void 0;
+}
+/**
+* Returns true if the content-encoding header indicates a compressed body
+* (gzip, br, deflate, x-gzip, x-deflate). Used to decide whether to send
+* body as base64 + content-encoding for backend decompression.
+*/
+function isCompressedContentEncoding(headerValue) {
+	const raw = normalizeHeaderValue(headerValue);
+	if (!raw) return false;
+	const first = raw.split(",")[0].trim().toLowerCase();
+	return COMPRESSED_ENCODINGS.has(first);
+}
+/**
+* Converts a buffer to a UTF-8 string for use as request/response body on spans.
+* Returns null for null, undefined, or empty buffer.
+*/
+function bufferToBodyString(buffer) {
+	if (buffer == null || buffer.length === 0) return null;
+	return buffer.toString("utf8");
+}
+
 //#endregion
 //#region src/utils/span-extractor.ts
 /**
@@ -612,7 +700,7 @@ function shouldCaptureBody(domainRule, globalConfig, bodyType) {
 */
 function extractSpanPayload(span, domainAllowList, globalHeadersAllowList, globalHeadersDenyList, globalCaptureRequestBody, globalCaptureResponseBody, headerRedaction) {
 	const attributes = span.attributes;
-	const url = attributes["http.url"] || attributes["url.full"];
+	const url = getHttpUrlFromAttributes(attributes);
 	const domainRule = url ? getDomainRule(url, domainAllowList) : void 0;
 	const headersAllowList = domainRule?.headersAllowList ?? globalHeadersAllowList;
 	const headersDenyList = domainRule?.headersDenyList ?? globalHeadersDenyList;
@@ -662,11 +750,10 @@ function extractSpanPayload(span, domainAllowList, globalHeadersAllowList, globa
 * OpenTelemetry context keys for PingOps
 */
 /**
-* Context key for enabling HTTP instrumentation.
-* When set to true, HTTP requests will be automatically instrumented.
-* This allows wrapHttp to control which HTTP calls are captured.
+* Context key for trace ID attribute.
+* Used to propagate trace identifier to all spans in the context.
 */
-const PINGOPS_HTTP_ENABLED = createContextKey("pingops-http-enabled");
+const PINGOPS_TRACE_ID = createContextKey("pingops-trace-id");
 /**
 * Context key for user ID attribute.
 * Used to propagate user identifier to all spans in the context.
@@ -690,13 +777,11 @@ const PINGOPS_METADATA = createContextKey("pingops-metadata");
 /**
 * Context key for capturing request body.
 * When set, controls whether request bodies should be captured for HTTP spans.
-* This allows wrapHttp to control body capture per-request.
 */
 const PINGOPS_CAPTURE_REQUEST_BODY = createContextKey("pingops-capture-request-body");
 /**
 * Context key for capturing response body.
 * When set, controls whether response bodies should be captured for HTTP spans.
-* This allows wrapHttp to control body capture per-request.
 */
 const PINGOPS_CAPTURE_RESPONSE_BODY = createContextKey("pingops-capture-response-body");
 
@@ -711,6 +796,8 @@ const PINGOPS_CAPTURE_RESPONSE_BODY = createContextKey("pingops-capture-response
 */
 function getPropagatedAttributesFromContext(parentContext) {
 	const attributes = {};
+	const traceId = parentContext.getValue(PINGOPS_TRACE_ID);
+	if (traceId !== void 0 && typeof traceId === "string") attributes["pingops.trace_id"] = traceId;
 	const userId = parentContext.getValue(PINGOPS_USER_ID);
 	if (userId !== void 0 && typeof userId === "string") attributes["pingops.user_id"] = userId;
 	const sessionId = parentContext.getValue(PINGOPS_SESSION_ID);
@@ -725,100 +812,30 @@ function getPropagatedAttributesFromContext(parentContext) {
 }
 
 //#endregion
-//#region src/wrap-http.ts
+//#region src/trace-id.ts
 /**
-* wrapHttp - Wraps a function to set attributes on HTTP spans created within the wrapped block.
-*
-* This function sets attributes (userId, sessionId, tags, metadata) in the OpenTelemetry
-* context, which are automatically propagated to all spans created within the wrapped function.
-*
-* Instrumentation behavior:
-* - If `initializePingops` was called: All HTTP requests are instrumented by default.
-*   `wrapHttp` only adds attributes to spans created within the wrapped block.
-* - If `initializePingops` was NOT called: Only HTTP requests within `wrapHttp` blocks
-*   are instrumented. Requests outside `wrapHttp` are not instrumented.
+* Deterministic and random trace ID generation for PingOps
 */
-const logger = createLogger("[PingOps wrapHttp]");
 /**
-* Wraps a function to set attributes on HTTP spans created within the wrapped block.
-*
-* This function sets attributes (userId, sessionId, tags, metadata) in the OpenTelemetry
-* context, which are automatically propagated to all spans created within the wrapped function.
-*
-* Instrumentation behavior:
-* - If `initializePingops` was called: All HTTP requests are instrumented by default.
-*   `wrapHttp` only adds attributes to spans created within the wrapped block.
-* - If `initializePingops` was NOT called: Only HTTP requests within `wrapHttp` blocks
-*   are instrumented. Requests outside `wrapHttp` are not instrumented.
-*
-* Note: This is the low-level API. For a simpler API with automatic setup,
-* use `wrapHttp` from `@pingops/sdk` instead.
-*
-* @param options - Options including attributes and required callbacks
-* @param fn - Function to execute within the attribute context
-* @returns The result of the function
-*/
-function wrapHttp(options, fn) {
-	logger.debug("wrapHttp called", {
-		hasAttributes: !!options.attributes,
-		hasUserId: !!options.attributes?.userId,
-		hasSessionId: !!options.attributes?.sessionId,
-		hasTags: !!options.attributes?.tags,
-		hasMetadata: !!options.attributes?.metadata
-	});
-	const normalizedOptions = "checkInitialized" in options && "isGlobalInstrumentationEnabled" in options ? options : (() => {
-		throw new Error("wrapHttp requires checkInitialized and isGlobalInstrumentationEnabled callbacks. Use wrapHttp from @pingops/sdk for automatic setup.");
-	})();
-	const { checkInitialized, ensureInitialized } = normalizedOptions;
-	if (checkInitialized()) {
-		logger.debug("SDK already initialized, executing wrapHttp synchronously");
-		return executeWrapHttpWithContext(normalizedOptions, fn);
-	}
-	if (ensureInitialized) {
-		logger.debug("SDK not initialized, using provided ensureInitialized callback");
-		return ensureInitialized().then(() => {
-			logger.debug("SDK initialized, executing wrapHttp");
-			return executeWrapHttpWithContext(normalizedOptions, fn);
-		}).catch((error) => {
-			logger.error("Failed to initialize SDK for wrapHttp", { error: error instanceof Error ? error.message : String(error) });
-			throw error;
-		});
-	}
-	logger.debug("SDK not initialized and no ensureInitialized callback provided, executing wrapHttp");
-	return executeWrapHttpWithContext(normalizedOptions, fn);
+* Converts a Uint8Array to a lowercase hex string.
+*/
+function uint8ArrayToHex(bytes) {
+	return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
-function executeWrapHttpWithContext(options, fn) {
-	const { attributes, isGlobalInstrumentationEnabled } = options;
-	const globalInstrumentationEnabled = isGlobalInstrumentationEnabled();
-	logger.debug("Executing wrapHttp context", {
-		hasAttributes: !!attributes,
-		globalInstrumentationEnabled
-	});
-	let contextWithAttributes = context.active();
-	if (!globalInstrumentationEnabled) contextWithAttributes = contextWithAttributes.setValue(PINGOPS_HTTP_ENABLED, true);
-	if (attributes) {
-		if (attributes.userId !== void 0) contextWithAttributes = contextWithAttributes.setValue(PINGOPS_USER_ID, attributes.userId);
-		if (attributes.sessionId !== void 0) contextWithAttributes = contextWithAttributes.setValue(PINGOPS_SESSION_ID, attributes.sessionId);
-		if (attributes.tags !== void 0) contextWithAttributes = contextWithAttributes.setValue(PINGOPS_TAGS, attributes.tags);
-		if (attributes.metadata !== void 0) contextWithAttributes = contextWithAttributes.setValue(PINGOPS_METADATA, attributes.metadata);
-		if (attributes.captureRequestBody !== void 0) contextWithAttributes = contextWithAttributes.setValue(PINGOPS_CAPTURE_REQUEST_BODY, attributes.captureRequestBody);
-		if (attributes.captureResponseBody !== void 0) contextWithAttributes = contextWithAttributes.setValue(PINGOPS_CAPTURE_RESPONSE_BODY, attributes.captureResponseBody);
+/**
+* Creates a trace ID (32 hex chars).
+* - If `seed` is provided: deterministic via SHA-256 of the seed (first 32 hex chars).
+* - Otherwise: random 16 bytes as 32 hex chars.
+*/
+async function createTraceId(seed) {
+	if (seed) {
+		const data = new TextEncoder().encode(seed);
+		const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+		return uint8ArrayToHex(new Uint8Array(hashBuffer)).slice(0, 32);
 	}
-	return context.with(contextWithAttributes, () => {
-		try {
-			const result = fn();
-			if (result instanceof Promise) return result.catch((err) => {
-				logger.error("Error in wrapHttp async execution", { error: err instanceof Error ? err.message : String(err) });
-				throw err;
-			});
-			return result;
-		} catch (err) {
-			logger.error("Error in wrapHttp sync execution", { error: err instanceof Error ? err.message : String(err) });
-			throw err;
-		}
-	});
+	return uint8ArrayToHex(crypto.getRandomValues(new Uint8Array(16)));
 }
 
 //#endregion
-export { DEFAULT_REDACTION_CONFIG, DEFAULT_SENSITIVE_HEADER_PATTERNS, HeaderRedactionStrategy, PINGOPS_CAPTURE_REQUEST_BODY, PINGOPS_CAPTURE_RESPONSE_BODY, PINGOPS_HTTP_ENABLED, PINGOPS_METADATA, PINGOPS_SESSION_ID, PINGOPS_TAGS, PINGOPS_USER_ID, createLogger, extractHeadersFromAttributes, extractSpanPayload, filterHeaders, getPropagatedAttributesFromContext, isSensitiveHeader, isSpanEligible, normalizeHeaders, redactHeaderValue, shouldCaptureSpan, wrapHttp };
+export { DEFAULT_REDACTION_CONFIG, DEFAULT_SENSITIVE_HEADER_PATTERNS, HTTP_RESPONSE_CONTENT_ENCODING, HeaderRedactionStrategy, PINGOPS_CAPTURE_REQUEST_BODY, PINGOPS_CAPTURE_RESPONSE_BODY, PINGOPS_METADATA, PINGOPS_SESSION_ID, PINGOPS_TAGS, PINGOPS_TRACE_ID, PINGOPS_USER_ID, bufferToBodyString, createLogger, createTraceId, extractHeadersFromAttributes, extractSpanPayload, filterHeaders, getHttpUrlFromAttributes, getPropagatedAttributesFromContext, hasHttpMethodAttribute, hasHttpUrlAttribute, isCompressedContentEncoding, isSensitiveHeader, isSpanEligible, normalizeHeaders, redactHeaderValue, shouldCaptureSpan, uint8ArrayToHex };
 //# sourceMappingURL=index.mjs.map