@pingops/otel 0.2.6 → 0.4.0

package/dist/index.cjs

@@ -35,6 +35,7 @@ let _opentelemetry_semantic_conventions = require("@opentelemetry/semantic-conve
 let http = require("http");
 let _opentelemetry_instrumentation_http = require("@opentelemetry/instrumentation-http");
 let _opentelemetry_core = require("@opentelemetry/core");
+let zlib = require("zlib");
 let diagnostics_channel = require("diagnostics_channel");
 diagnostics_channel = __toESM(diagnostics_channel);
 let url = require("url");
@@ -59,7 +60,7 @@ function getGlobalConfig() {
 
 //#endregion
 //#region src/span-processor.ts
-const logger$2 = (0, _pingops_core.createLogger)("[PingOps Processor]");
+const logger$3 = (0, _pingops_core.createLogger)("[PingOps Processor]");
 function normalizePath$1(pathname) {
 	return pathname.replace(/\/+/g, "/").replace(/\/$/, "");
 }
@@ -89,10 +90,10 @@ function isExporterRequestUrl$1(url$1, exporterUrl) {
 *
 * This allows us to filter headers before the span is serialized by OTLP exporter
 */
-function createFilteredSpan(span, domainAllowList, globalHeadersAllowList, globalHeadersDenyList, globalCaptureRequestBody, globalCaptureResponseBody, headerRedaction) {
-	const payload = (0, _pingops_core.extractSpanPayload)(span, domainAllowList, globalHeadersAllowList, globalHeadersDenyList, globalCaptureRequestBody, globalCaptureResponseBody, headerRedaction);
+function createFilteredSpan(span, domainAllowList, globalCaptureRequestBody, globalCaptureResponseBody, transforms) {
+	const payload = (0, _pingops_core.extractSpanPayload)(span, domainAllowList, globalCaptureRequestBody, globalCaptureResponseBody, transforms);
 	const filteredAttributes = payload?.attributes ?? span.attributes;
-	logger$2.debug("Payload", { payload });
+	logger$3.debug("Payload", { payload });
 	return new Proxy(span, { get(target, prop) {
 		if (prop === "attributes") return filteredAttributes;
 		const value = target[prop];
@@ -134,31 +135,28 @@ var PingopsSpanProcessor = class {
 		});
 		this.config = {
 			debug: config.debug ?? false,
-			headersAllowList: config.headersAllowList,
-			headersDenyList: config.headersDenyList,
+			sdkVersion: config.sdkVersion,
 			domainAllowList: config.domainAllowList,
 			domainDenyList: config.domainDenyList,
 			captureRequestBody: config.captureRequestBody,
 			captureResponseBody: config.captureResponseBody,
-			headerRedaction: config.headerRedaction
+			transforms: config.transforms
 		};
 		setGlobalConfig({
 			captureRequestBody: config.captureRequestBody,
 			captureResponseBody: config.captureResponseBody,
 			domainAllowList: config.domainAllowList,
-			maxRequestBodySize: config.maxRequestBodySize,
-			maxResponseBodySize: config.maxResponseBodySize,
-			exportTraceUrl: this.exporterTraceUrl
+			exportTraceUrl: this.exporterTraceUrl,
+			llmMonitoring: config.llmMonitoring
 		});
-		logger$2.info("Initialized PingopsSpanProcessor", {
+		logger$3.info("Initialized PingopsSpanProcessor", {
 			baseUrl: config.baseUrl,
 			exportMode,
 			batchSize: config.batchSize,
 			batchTimeout: config.batchTimeout,
 			hasDomainAllowList: !!config.domainAllowList && config.domainAllowList.length > 0,
 			hasDomainDenyList: !!config.domainDenyList && config.domainDenyList.length > 0,
-			hasHeadersAllowList: !!config.headersAllowList && config.headersAllowList.length > 0,
-			hasHeadersDenyList: !!config.headersDenyList && config.headersDenyList.length > 0
+			hasTransforms: !!config.transforms
 		});
 	}
 	/**
@@ -166,15 +164,16 @@ var PingopsSpanProcessor = class {
 	*/
 	onStart(span, parentContext) {
 		const spanContext = span.spanContext();
-		logger$2.debug("Span started", {
+		logger$3.debug("Span started", {
 			spanName: span.name,
 			spanId: spanContext.spanId,
 			traceId: spanContext.traceId
 		});
+		if (this.config.sdkVersion) span.setAttribute("pingops.sdk.version", this.config.sdkVersion);
 		const propagatedAttributes = (0, _pingops_core.getPropagatedAttributesFromContext)(parentContext);
 		if (Object.keys(propagatedAttributes).length > 0) {
 			for (const [key, value] of Object.entries(propagatedAttributes)) if (typeof value === "string" || Array.isArray(value)) span.setAttribute(key, value);
-			logger$2.debug("Set propagated attributes on span", {
+			logger$3.debug("Set propagated attributes on span", {
 				spanName: span.name,
 				attributeKeys: Object.keys(propagatedAttributes)
 			});
@@ -192,7 +191,7 @@ var PingopsSpanProcessor = class {
 	*/
 	onEnd(span) {
 		const spanContext = span.spanContext();
-		logger$2.debug("Span ended, processing", {
+		logger$3.debug("Span ended, processing", {
 			spanName: span.name,
 			spanId: spanContext.spanId,
 			traceId: spanContext.traceId,
@@ -200,7 +199,7 @@ var PingopsSpanProcessor = class {
 		});
 		try {
 			if (!(0, _pingops_core.isSpanEligible)(span)) {
-				logger$2.debug("Span not eligible, skipping", {
+				logger$3.debug("Span not eligible, skipping", {
 					spanName: span.name,
 					spanId: spanContext.spanId,
 					reason: "not CLIENT or missing HTTP/GenAI attributes"
@@ -210,14 +209,14 @@ var PingopsSpanProcessor = class {
 			const attributes = span.attributes;
 			const url$1 = (0, _pingops_core.getHttpUrlFromAttributes)(attributes) ?? "";
 			if (url$1 && isExporterRequestUrl$1(url$1, this.exporterTraceUrl)) {
-				logger$2.debug("Skipping exporter span to prevent self-instrumentation", {
+				logger$3.debug("Skipping exporter span to prevent self-instrumentation", {
 					spanName: span.name,
 					spanId: spanContext.spanId,
 					url: url$1
 				});
 				return;
 			}
-			logger$2.debug("Extracted URL for domain filtering", {
+			logger$3.debug("Extracted URL for domain filtering", {
 				spanName: span.name,
 				url: url$1,
 				hasHttpUrl: !!attributes["http.url"],
@@ -226,25 +225,25 @@ var PingopsSpanProcessor = class {
 			});
 			if (url$1) {
 				if (!(0, _pingops_core.shouldCaptureSpan)(url$1, this.config.domainAllowList, this.config.domainDenyList)) {
-					logger$2.info("Span filtered out by domain rules", {
+					logger$3.info("Span filtered out by domain rules", {
 						spanName: span.name,
 						spanId: spanContext.spanId,
 						url: url$1
 					});
 					return;
 				}
-			} else logger$2.debug("No URL found for domain filtering, proceeding", { spanName: span.name });
-			const filteredSpan = createFilteredSpan(span, this.config.domainAllowList, this.config.headersAllowList, this.config.headersDenyList, this.config.captureRequestBody, this.config.captureResponseBody, this.config.headerRedaction);
+			} else logger$3.debug("No URL found for domain filtering, proceeding", { spanName: span.name });
+			const filteredSpan = createFilteredSpan(span, this.config.domainAllowList, this.config.captureRequestBody, this.config.captureResponseBody, this.config.transforms);
 			this.processor.onEnd(filteredSpan);
-			logger$2.info("Span passed all filters and queued for export", {
+			logger$3.info("Span passed all filters and queued for export", {
 				spanName: span.name,
 				spanId: spanContext.spanId,
 				traceId: spanContext.traceId,
 				url: url$1,
-				hasHeaderFiltering: !!(this.config.headersAllowList || this.config.headersDenyList)
+				hasTransforms: !!this.config.transforms
 			});
 		} catch (error) {
-			logger$2.error("Error processing span", {
+			logger$3.error("Error processing span", {
 				spanName: span.name,
 				spanId: spanContext.spanId,
 				error: error instanceof Error ? error.message : String(error)
@@ -257,12 +256,12 @@ var PingopsSpanProcessor = class {
 	* @returns Promise that resolves when all pending operations are complete
 	*/
 	async forceFlush() {
-		logger$2.info("Force flushing spans");
+		logger$3.info("Force flushing spans");
 		try {
 			await this.processor.forceFlush();
-			logger$2.info("Force flush complete");
+			logger$3.info("Force flush complete");
 		} catch (error) {
-			logger$2.error("Error during force flush", { error: error instanceof Error ? error.message : String(error) });
+			logger$3.error("Error during force flush", { error: error instanceof Error ? error.message : String(error) });
 			throw error;
 		}
 	}
@@ -272,12 +271,12 @@ var PingopsSpanProcessor = class {
 	* @returns Promise that resolves when shutdown is complete
 	*/
 	async shutdown() {
-		logger$2.info("Shutting down processor");
+		logger$3.info("Shutting down processor");
 		try {
 			await this.processor.shutdown();
-			logger$2.info("Processor shutdown complete");
+			logger$3.info("Processor shutdown complete");
 		} catch (error) {
-			logger$2.error("Error during processor shutdown", { error: error instanceof Error ? error.message : String(error) });
+			logger$3.error("Error during processor shutdown", { error: error instanceof Error ? error.message : String(error) });
 			throw error;
 		}
 	}
@@ -292,7 +291,7 @@ const PINGOPS_GLOBAL_SYMBOL = Symbol.for("pingops");
 /**
 * Logger instance for tracer provider
 */
-const logger$1 = (0, _pingops_core.createLogger)("[PingOps TracerProvider]");
+const logger$2 = (0, _pingops_core.createLogger)("[PingOps TracerProvider]");
 /**
 * Creates initial global state
 */
@@ -307,21 +306,21 @@ function getGlobalState() {
 	try {
 		const g = globalThis;
 		if (typeof g !== "object" || g === null) {
-			logger$1.warn("globalThis is not available, using fallback state");
+			logger$2.warn("globalThis is not available, using fallback state");
 			return initialState;
 		}
 		if (!g[PINGOPS_GLOBAL_SYMBOL]) {
-			logger$1.debug("Creating new global state");
+			logger$2.debug("Creating new global state");
 			Object.defineProperty(g, PINGOPS_GLOBAL_SYMBOL, {
 				value: initialState,
 				writable: false,
 				configurable: false,
 				enumerable: false
 			});
-		} else logger$1.debug("Retrieved existing global state");
+		} else logger$2.debug("Retrieved existing global state");
 		return g[PINGOPS_GLOBAL_SYMBOL];
 	} catch (err) {
-		logger$1.error("Failed to access global state:", err instanceof Error ? err.message : String(err));
+		logger$2.error("Failed to access global state:", err instanceof Error ? err.message : String(err));
 		return initialState;
 	}
 }
@@ -339,11 +338,11 @@ function setPingopsTracerProvider(provider) {
 	const state = getGlobalState();
 	const hadProvider = state.isolatedTracerProvider !== null;
 	state.isolatedTracerProvider = provider;
-	if (provider) logger$1.info("Set isolated TracerProvider", {
+	if (provider) logger$2.info("Set isolated TracerProvider", {
 		hadPrevious: hadProvider,
 		providerType: provider.constructor.name
 	});
-	else logger$1.info("Cleared isolated TracerProvider", { hadPrevious: hadProvider });
+	else logger$2.info("Cleared isolated TracerProvider", { hadPrevious: hadProvider });
 }
 /**
 * Gets the TracerProvider for PingOps tracing operations.
@@ -357,36 +356,36 @@ function setPingopsTracerProvider(provider) {
 function getPingopsTracerProvider() {
 	const { isolatedTracerProvider } = getGlobalState();
 	if (isolatedTracerProvider) {
-		logger$1.debug("Using isolated TracerProvider", { providerType: isolatedTracerProvider.constructor.name });
+		logger$2.debug("Using isolated TracerProvider", { providerType: isolatedTracerProvider.constructor.name });
 		return isolatedTracerProvider;
 	}
 	const globalProvider = _opentelemetry_api.trace.getTracerProvider();
-	logger$1.debug("Using global TracerProvider", { providerType: globalProvider.constructor.name });
+	logger$2.debug("Using global TracerProvider", { providerType: globalProvider.constructor.name });
 	return globalProvider;
 }
 /**
 * Shuts down the TracerProvider and flushes remaining spans
 */
 async function shutdownTracerProvider() {
-	logger$1.info("Shutting down TracerProvider");
+	logger$2.info("Shutting down TracerProvider");
 	const providerWithShutdown = getPingopsTracerProvider();
 	if (providerWithShutdown && typeof providerWithShutdown.shutdown === "function") {
-		logger$1.debug("Calling provider.shutdown()");
+		logger$2.debug("Calling provider.shutdown()");
 		try {
 			await providerWithShutdown.shutdown();
-			logger$1.info("TracerProvider shutdown complete");
+			logger$2.info("TracerProvider shutdown complete");
 		} catch (error) {
-			logger$1.error("Error during TracerProvider shutdown:", error instanceof Error ? error.message : String(error));
+			logger$2.error("Error during TracerProvider shutdown:", error instanceof Error ? error.message : String(error));
 			throw error;
 		}
-	} else logger$1.warn("TracerProvider does not have shutdown method, skipping");
+	} else logger$2.warn("TracerProvider does not have shutdown method, skipping");
 	setPingopsTracerProvider(null);
-	logger$1.info("TracerProvider shutdown finished");
+	logger$2.info("TracerProvider shutdown finished");
 }
 
 //#endregion
 //#region src/instrumentations/suppression-guard.ts
-const logger = (0, _pingops_core.createLogger)("[PingOps SuppressionGuard]");
+const logger$1 = (0, _pingops_core.createLogger)("[PingOps SuppressionGuard]");
 let hasLoggedSuppressionLeakWarning = false;
 function normalizePath(pathname) {
 	return pathname.replace(/\/+/g, "/").replace(/\/$/, "");
@@ -423,26 +422,496 @@ function shouldIgnoreOutboundInstrumentation(requestUrl) {
 */
 function resolveOutboundSpanParentContext(activeContext, requestUrl) {
 	if (!(0, _opentelemetry_core.isTracingSuppressed)(activeContext)) return activeContext;
+	if (activeContext.getValue(_pingops_core.PINGOPS_INTENTIONAL_SUPPRESSION) === true) return activeContext;
 	if (isExporterRequestUrl(requestUrl)) return activeContext;
 	if (!hasLoggedSuppressionLeakWarning) {
-		logger.warn("Detected suppressed context for outbound user request; running instrumentation on ROOT_CONTEXT to prevent Noop spans from suppression leakage");
+		logger$1.warn("Detected suppressed context for outbound user request; running instrumentation on ROOT_CONTEXT to prevent Noop spans from suppression leakage");
 		hasLoggedSuppressionLeakWarning = true;
-	} else logger.debug("Suppressed context detected for outbound user request; using ROOT_CONTEXT");
+	} else logger$1.debug("Suppressed context detected for outbound user request; using ROOT_CONTEXT");
 	return _opentelemetry_api.ROOT_CONTEXT;
 }
 
+//#endregion
+//#region src/instrumentations/body-utils.ts
+const HTTP_REQUEST_BODY = "http.request.body";
+const HTTP_RESPONSE_BODY = "http.response.body";
+const HTTP_REQUEST_BODY_SIZE = "http.request.body.size";
+const HTTP_RESPONSE_BODY_SIZE = "http.response.body.size";
+const UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
+const BINARY_CONTENT_TYPES = new Set([
+	"application/octet-stream",
+	"application/pdf",
+	"application/zip",
+	"application/gzip",
+	"application/x-gzip",
+	"image/jpeg",
+	"image/jpg",
+	"image/png",
+	"image/gif",
+	"image/webp",
+	"image/bmp",
+	"image/tiff",
+	"image/ico",
+	"audio/mpeg",
+	"audio/mp3",
+	"audio/wav",
+	"audio/ogg",
+	"audio/webm",
+	"video/mp4",
+	"video/webm",
+	"video/ogg",
+	"video/avi",
+	"video/mov"
+]);
+/**
+* Gets domain rule configuration for a given URL.
+*/
+function getDomainRule(url$1, domainAllowList) {
+	if (!domainAllowList) return;
+	const domain = (0, _pingops_core.extractDomainFromUrl)(url$1);
+	for (const rule of domainAllowList) if (domain === rule.domain || domain.endsWith(`.${rule.domain}`) || domain === rule.domain.slice(1)) return rule;
+}
+/**
+* Determines if request body should be captured based on priority:
+* context > domain rule > global config > default (false).
+*/
+function shouldCaptureRequestBody(url$1) {
+	const contextValue = _opentelemetry_api.context.active().getValue(_pingops_core.PINGOPS_CAPTURE_REQUEST_BODY);
+	if (contextValue !== void 0) return contextValue;
+	if (url$1) {
+		const domainRule = getDomainRule(url$1, getGlobalConfig()?.domainAllowList);
+		if (domainRule?.captureRequestBody !== void 0) return domainRule.captureRequestBody;
+	}
+	const globalConfig$1 = getGlobalConfig();
+	if (globalConfig$1?.captureRequestBody !== void 0) return globalConfig$1.captureRequestBody;
+	return false;
+}
+/**
+* Determines if response body should be captured based on priority:
+* context > domain rule > global config > default (false).
+*/
+function shouldCaptureResponseBody(url$1) {
+	const contextValue = _opentelemetry_api.context.active().getValue(_pingops_core.PINGOPS_CAPTURE_RESPONSE_BODY);
+	if (contextValue !== void 0) return contextValue;
+	if (url$1) {
+		const domainRule = getDomainRule(url$1, getGlobalConfig()?.domainAllowList);
+		if (domainRule?.captureResponseBody !== void 0) return domainRule.captureResponseBody;
+	}
+	const globalConfig$1 = getGlobalConfig();
+	if (globalConfig$1?.captureResponseBody !== void 0) return globalConfig$1.captureResponseBody;
+	return false;
+}
+/**
+* Normalizes supported HTTP chunk types into a Buffer.
+*/
+function toBufferChunk(data) {
+	if (typeof data === "string") return Buffer.from(data);
+	if (Buffer.isBuffer(data)) return data;
+	if (data instanceof Uint8Array) return Buffer.from(data);
+	return null;
+}
+/**
+* Parses a content-length value into a positive byte count.
+*/
+function parseContentLength(value) {
+	if (typeof value === "number") return Number.isFinite(value) && value >= 0 ? value : void 0;
+	if (typeof value === "string") {
+		const parsed = Number(value);
+		return Number.isFinite(parsed) && parsed >= 0 ? parsed : void 0;
+	}
+	if (Array.isArray(value) && value.length > 0) return parseContentLength(value[0]);
+}
+function normalizeHeaderValue$1(v) {
+	if (typeof v === "string") {
+		const trimmed = v.trim();
+		return trimmed.length > 0 ? trimmed : void 0;
+	}
+	if (Array.isArray(v) && v.length > 0) return normalizeHeaderValue$1(v[0]);
+	if (typeof v === "number" && Number.isFinite(v)) return String(v);
+}
+function parseContentTypeMainType(contentType) {
+	const normalized = normalizeHeaderValue$1(contentType);
+	if (!normalized) return;
+	return normalized.toLowerCase().split(";")[0]?.trim() || void 0;
+}
+function isUtf8(buffer) {
+	if (buffer.length === 0) return true;
+	try {
+		UTF8_DECODER.decode(buffer);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Encodes HTTP body for span attributes:
+* - compressed payloads => base64 (backend can decode)
+* - known binary content-types => base64
+* - known textual/utf8 payloads => utf8
+*/
+function encodeBodyBufferForSpan(buffer, headers) {
+	if (!buffer || buffer.length === 0) return null;
+	const contentEncoding = normalizeHeaderValue$1(headers?.["content-encoding"]);
+	if ((0, _pingops_core.isCompressedContentEncoding)(contentEncoding)) return {
+		content: buffer.toString("base64"),
+		contentEncoding: contentEncoding?.split(",")[0]?.trim().toLowerCase() || void 0
+	};
+	const contentType = parseContentTypeMainType(headers?.["content-type"]);
+	if (contentType && BINARY_CONTENT_TYPES.has(contentType)) return { content: buffer.toString("base64") };
+	if (isUtf8(buffer)) return { content: buffer.toString("utf8") };
+	return { content: buffer.toString("base64") };
+}
+
+//#endregion
+//#region src/llm/types.ts
+const GEN_AI_ATTRS = {
+	SYSTEM: "gen_ai.system",
+	PROVIDER_NAME: "gen_ai.provider.name",
+	OPERATION_NAME: "gen_ai.operation.name",
+	REQUEST_MODEL: "gen_ai.request.model",
+	RESPONSE_MODEL: "gen_ai.response.model",
+	RESPONSE_ID: "gen_ai.response.id",
+	USAGE_INPUT_TOKENS: "gen_ai.usage.input_tokens",
+	USAGE_OUTPUT_TOKENS: "gen_ai.usage.output_tokens"
+};
+const PINGOPS_GEN_AI_ATTRS = {
+	TOTAL_TOKENS: "pingops.gen_ai.usage.total_tokens",
+	CACHE_READ_INPUT_TOKENS: "pingops.gen_ai.usage.cache_read_input_tokens",
+	CACHE_CREATION_INPUT_TOKENS: "pingops.gen_ai.usage.cache_creation_input_tokens",
+	CACHE_TOKENS: "pingops.gen_ai.usage.cache_tokens"
+};
+const DEFAULT_LLM_MONITORING_CONFIG = {
+	enabled: false,
+	streaming: true
+};
+function normalizeLlmMonitoringConfig(config) {
+	return {
+		enabled: config?.enabled ?? DEFAULT_LLM_MONITORING_CONFIG.enabled,
+		streaming: config?.streaming ?? DEFAULT_LLM_MONITORING_CONFIG.streaming
+	};
+}
+
+//#endregion
+//#region src/llm/provider-detector.ts
+function hostMatches(host, suffixes) {
+	return suffixes.some((suffix) => host === suffix || host.endsWith(`.${suffix}`));
+}
+function includesAny(pathname, values) {
+	return values.some((value) => pathname.includes(value));
+}
+function detectLlmProvider(url$1, llmConfig) {
+	if (!url$1) return;
+	if (!normalizeLlmMonitoringConfig(llmConfig).enabled) return;
+	try {
+		const parsed = new URL(url$1);
+		const host = parsed.hostname.toLowerCase();
+		const path = parsed.pathname.toLowerCase();
+		const maybeProvider = [];
+		if (hostMatches(host, ["x.ai", "api.x.ai"])) maybeProvider.push({
+			provider: "xai",
+			providerName: "xai"
+		});
+		if (hostMatches(host, ["openai.com", "api.openai.com"]) || includesAny(path, [
+			"/v1/chat/completions",
+			"/v1/responses",
+			"/v1/completions"
+		]) && !host.includes("x.ai")) maybeProvider.push({
+			provider: "openai",
+			providerName: "openai"
+		});
+		if (hostMatches(host, ["anthropic.com", "api.anthropic.com"]) || includesAny(path, ["/v1/messages", "/v1/complete"]) && host.includes("anthropic")) maybeProvider.push({
+			provider: "anthropic",
+			providerName: "anthropic"
+		});
+		if (hostMatches(host, ["googleapis.com", "generativelanguage.googleapis.com"]) || includesAny(path, [
+			":generatecontent",
+			":streamgeneratecontent",
+			"/models/"
+		])) {
+			if (host.includes("google") || path.includes("generatecontent")) maybeProvider.push({
+				provider: "gemini",
+				providerName: "gemini"
+			});
+		}
+		return maybeProvider[0];
+	} catch {
+		return;
+	}
+}
+function deriveOperationName(url$1) {
+	if (!url$1) return;
+	try {
+		const pathname = new URL(url$1).pathname.toLowerCase();
+		if (pathname.includes("/embeddings")) return "embeddings";
+		if (pathname.includes("/responses")) return "responses";
+		if (pathname.includes("/chat/completions") || pathname.includes("/messages")) return "chat.completions";
+		if (pathname.includes("/completions") || pathname.includes("/complete")) return "completions";
+		if (pathname.includes("generatecontent")) return "chat.completions";
+		return;
+	} catch {
+		return;
+	}
+}
+
+//#endregion
+//#region src/llm/request-parser.ts
+function tryParseJson(raw) {
+	if (!raw || raw.length === 0) return;
+	try {
+		const parsed = JSON.parse(raw);
+		if (typeof parsed === "object" && parsed !== null) return parsed;
+		return;
+	} catch {
+		return;
+	}
+}
+function getStringField(obj, key) {
+	if (!obj) return;
+	const value = obj[key];
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function parseLlmRequestData(provider, requestBody, url$1) {
+	const parsed = tryParseJson(requestBody);
+	const data = {};
+	if (provider === "openai" || provider === "xai") data.model = getStringField(parsed, "model") || getStringField(parsed, "response_model") || void 0;
+	else if (provider === "anthropic") data.model = getStringField(parsed, "model") || void 0;
+	else if (provider === "gemini") data.model = getStringField(parsed, "model") || getModelFromGeminiPath(url$1);
+	return data;
+}
+function getModelFromGeminiPath(url$1) {
+	if (!url$1) return;
+	try {
+		const pathname = new URL(url$1).pathname;
+		const markerIndex = pathname.indexOf("/models/");
+		if (markerIndex < 0) return;
+		const modelPart = pathname.slice(markerIndex + 8);
+		const endIndex = modelPart.indexOf(":");
+		const candidate = endIndex >= 0 ? modelPart.slice(0, endIndex) : modelPart;
+		return candidate.length > 0 ? candidate : void 0;
+	} catch {
+		return;
+	}
+}
+
+//#endregion
+//#region src/llm/response-parser.ts
+function toNonNegativeNumber(value) {
+	if (typeof value !== "number" || Number.isNaN(value) || value < 0) return;
+	return value;
+}
+function parseOpenAiLikeUsage(response) {
+	const usage = typeof response.usage === "object" && response.usage !== null ? response.usage : void 0;
+	const promptDetails = usage && typeof usage.prompt_tokens_details === "object" && usage.prompt_tokens_details !== null ? usage.prompt_tokens_details : void 0;
+	return {
+		responseModel: typeof response.model === "string" ? response.model : void 0,
+		responseId: typeof response.id === "string" ? response.id : void 0,
+		inputTokens: usage ? toNonNegativeNumber(usage.prompt_tokens) : void 0,
+		outputTokens: usage ? toNonNegativeNumber(usage.completion_tokens) : void 0,
+		totalTokens: usage ? toNonNegativeNumber(usage.total_tokens) : void 0,
+		cacheReadInputTokens: promptDetails ? toNonNegativeNumber(promptDetails.cached_tokens) : void 0
+	};
+}
+function parseAnthropicUsage(response) {
+	const message = typeof response.message === "object" && response.message !== null ? response.message : void 0;
+	const usage = typeof response.usage === "object" && response.usage !== null ? response.usage : message && typeof message.usage === "object" && message.usage !== null ? message.usage : void 0;
+	return {
+		responseModel: typeof response.model === "string" ? response.model : typeof message?.model === "string" ? message.model : void 0,
+		responseId: typeof response.id === "string" ? response.id : typeof message?.id === "string" ? message.id : void 0,
+		inputTokens: usage ? toNonNegativeNumber(usage.input_tokens) : void 0,
+		outputTokens: usage ? toNonNegativeNumber(usage.output_tokens) : void 0,
+		totalTokens: usage && (toNonNegativeNumber(usage.input_tokens) !== void 0 || toNonNegativeNumber(usage.output_tokens) !== void 0) ? (toNonNegativeNumber(usage.input_tokens) ?? 0) + (toNonNegativeNumber(usage.output_tokens) ?? 0) : void 0,
+		cacheReadInputTokens: usage ? toNonNegativeNumber(usage.cache_read_input_tokens) : void 0,
+		cacheCreationInputTokens: usage ? toNonNegativeNumber(usage.cache_creation_input_tokens) : void 0
+	};
+}
+function parseGeminiUsage(response) {
+	const usage = typeof response.usageMetadata === "object" && response.usageMetadata !== null ? response.usageMetadata : void 0;
+	let responseModel;
+	if (typeof response.modelVersion === "string") responseModel = response.modelVersion;
+	else if (Array.isArray(response.candidates) && response.candidates.length > 0) {
+		const first = response.candidates[0];
+		if (typeof first === "object" && first !== null && "model" in first) responseModel = typeof first.model === "string" ? first.model : void 0;
+	}
+	return {
+		responseModel,
+		responseId: typeof response.responseId === "string" ? response.responseId : void 0,
+		inputTokens: usage ? toNonNegativeNumber(usage.promptTokenCount) : void 0,
+		outputTokens: usage ? toNonNegativeNumber(usage.candidatesTokenCount) : void 0,
+		totalTokens: usage ? toNonNegativeNumber(usage.totalTokenCount) : void 0,
+		cacheReadInputTokens: usage ? toNonNegativeNumber(usage.cachedContentTokenCount) : void 0
+	};
+}
+function parseJsonObject(raw) {
+	if (!raw || raw.length === 0) return;
+	try {
+		const value = JSON.parse(raw);
+		if (typeof value === "object" && value !== null) return value;
+		return;
+	} catch {
+		return;
+	}
+}
+function mergeUsage(target, next) {
+	return {
+		responseModel: next.responseModel ?? target.responseModel,
+		responseId: next.responseId ?? target.responseId,
+		inputTokens: next.inputTokens ?? target.inputTokens,
+		outputTokens: next.outputTokens ?? target.outputTokens,
+		totalTokens: next.totalTokens ?? target.totalTokens,
+		cacheReadInputTokens: next.cacheReadInputTokens ?? target.cacheReadInputTokens,
+		cacheCreationInputTokens: next.cacheCreationInputTokens ?? target.cacheCreationInputTokens
+	};
+}
+function parseByProvider(provider, object) {
+	if (provider === "openai" || provider === "xai") return parseOpenAiLikeUsage(object);
+	if (provider === "anthropic") return parseAnthropicUsage(object);
+	return parseGeminiUsage(object);
+}
+function parseSsePayload(provider, raw) {
+	if (!raw || raw.length === 0) return {};
+	let acc = {};
+	const lines = raw.split(/\r?\n/);
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed.startsWith("data:")) continue;
+		const payload = trimmed.slice(5).trim();
+		if (payload.length === 0 || payload === "[DONE]") continue;
+		const parsed = parseJsonObject(payload);
+		if (!parsed) continue;
+		acc = mergeUsage(acc, parseByProvider(provider, parsed));
+	}
+	return acc;
+}
+function parseLlmResponseData(provider, responseBody, streaming = true) {
+	if (!responseBody || responseBody.length === 0) return {};
+	const parsedJson = parseJsonObject(responseBody);
+	if (parsedJson) return parseByProvider(provider, parsedJson);
+	if (!streaming) return {};
+	return parseSsePayload(provider, responseBody);
+}
+
+//#endregion
+//#region src/llm/enricher.ts
+const logger = (0, _pingops_core.createLogger)("[PingOps LLM Enricher]");
+function getEffectiveConfig() {
+	return normalizeLlmMonitoringConfig(getGlobalConfig()?.llmMonitoring);
+}
+function createLlmEnrichmentState(span, url$1, requestMethod, requestHeaders) {
+	const config = getEffectiveConfig();
+	if (!config.enabled) return;
+	const detection = detectLlmProvider(url$1, config);
+	if (!detection) return;
+	return {
+		span,
+		url: url$1,
+		requestMethod,
+		requestHeaders,
+		detection,
+		requestData: void 0,
+		responseData: void 0,
+		responseHeaders: void 0,
+		requestParseBytes: 0,
+		responseParseBytes: 0,
+		requestBodyBuffer: [],
+		responseBodyBuffer: [],
+		requestParseStopped: false,
+		responseParseStopped: false
+	};
+}
+function updateLlmRequestHeaders(state, headers) {
+	state.requestHeaders = headers;
+}
+function updateLlmResponseHeaders(state, headers) {
+	state.responseHeaders = headers;
+}
+function appendLlmRequestChunk(state, chunk) {
+	state.requestBodyBuffer.push(chunk);
+	state.requestParseBytes += chunk.length;
+}
+function appendLlmResponseChunk(state, chunk) {
+	state.responseBodyBuffer.push(chunk);
+	state.responseParseBytes += chunk.length;
+}
+function computeTotalTokens(responseData) {
+	if (responseData.totalTokens !== void 0) return responseData.totalTokens;
+	if (responseData.inputTokens !== void 0 || responseData.outputTokens !== void 0) return (responseData.inputTokens ?? 0) + (responseData.outputTokens ?? 0);
+}
+function normalizeHeaderValue(value) {
+	if (typeof value === "string") return value;
+	if (Array.isArray(value) && value.length > 0) return value.join(",");
+}
+function decodeResponseBody(body, headers) {
+	const encodingValue = normalizeHeaderValue(headers?.["content-encoding"]);
+	if (!encodingValue || encodingValue.trim().length === 0) return body.toString("utf8");
+	const encodings = encodingValue.toLowerCase().split(",").map((v) => v.trim()).filter(Boolean);
+	if (encodings.length === 0 || encodings.includes("identity")) return body.toString("utf8");
+	let decoded = body;
+	for (let i = encodings.length - 1; i >= 0; i -= 1) {
+		const encoding = encodings[i];
+		if (encoding === "gzip" || encoding === "x-gzip") {
+			decoded = (0, zlib.gunzipSync)(decoded);
+			continue;
+		}
+		if (encoding === "deflate") {
+			decoded = (0, zlib.inflateSync)(decoded);
+			continue;
+		}
+		if (encoding === "br") {
+			decoded = (0, zlib.brotliDecompressSync)(decoded);
+			continue;
+		}
+		return body.toString("utf8");
+	}
+	return decoded.toString("utf8");
+}
+function finalizeLlmEnrichment(state) {
+	const config = getEffectiveConfig();
+	if (!config.enabled || !state.detection) return;
+	try {
+		const requestBody = state.requestBodyBuffer.length > 0 ? Buffer.concat(state.requestBodyBuffer).toString("utf8") : void 0;
+		if (state.requestData === void 0) state.requestData = parseLlmRequestData(state.detection.provider, requestBody, state.url);
+		const operationName = deriveOperationName(state.url);
+		const responseBody = state.responseBodyBuffer.length > 0 ? decodeResponseBody(Buffer.concat(state.responseBodyBuffer), state.responseHeaders) : void 0;
+		const parsedResponse = responseBody ? parseLlmResponseData(state.detection.provider, responseBody, config.streaming) : {};
+		state.responseData = {
+			...state.responseData,
+			...parsedResponse
+		};
+		state.span.setAttribute(GEN_AI_ATTRS.SYSTEM, state.detection.provider);
+		state.span.setAttribute(GEN_AI_ATTRS.PROVIDER_NAME, state.detection.providerName);
+		if (operationName) state.span.setAttribute(GEN_AI_ATTRS.OPERATION_NAME, operationName);
+		if (state.requestData?.model) state.span.setAttribute(GEN_AI_ATTRS.REQUEST_MODEL, state.requestData.model);
+		if (state.responseData?.responseModel) state.span.setAttribute(GEN_AI_ATTRS.RESPONSE_MODEL, state.responseData.responseModel);
+		if (state.responseData?.responseId) state.span.setAttribute(GEN_AI_ATTRS.RESPONSE_ID, state.responseData.responseId);
+		if (state.responseData?.inputTokens !== void 0) state.span.setAttribute(GEN_AI_ATTRS.USAGE_INPUT_TOKENS, state.responseData.inputTokens);
+		if (state.responseData?.outputTokens !== void 0) state.span.setAttribute(GEN_AI_ATTRS.USAGE_OUTPUT_TOKENS, state.responseData.outputTokens);
+		const totalTokens = state.responseData ? computeTotalTokens(state.responseData) : void 0;
+		if (totalTokens !== void 0) state.span.setAttribute(PINGOPS_GEN_AI_ATTRS.TOTAL_TOKENS, totalTokens);
+		if (state.responseData?.cacheReadInputTokens !== void 0) state.span.setAttribute(PINGOPS_GEN_AI_ATTRS.CACHE_READ_INPUT_TOKENS, state.responseData.cacheReadInputTokens);
+		if (state.responseData?.cacheCreationInputTokens !== void 0) state.span.setAttribute(PINGOPS_GEN_AI_ATTRS.CACHE_CREATION_INPUT_TOKENS, state.responseData.cacheCreationInputTokens);
+		const cacheTokens = (state.responseData?.cacheReadInputTokens ?? 0) + (state.responseData?.cacheCreationInputTokens ?? 0);
+		if (cacheTokens > 0) state.span.setAttribute(PINGOPS_GEN_AI_ATTRS.CACHE_TOKENS, cacheTokens);
+	} catch (error) {
+		logger.debug("Failed to enrich LLM attributes", {
+			error: error instanceof Error ? error.message : String(error),
+			url: state.url,
+			provider: state.detection.provider
+		});
+	}
+}
+
 //#endregion
 //#region src/instrumentations/http/pingops-http.ts
 /**
 * Pingops HTTP instrumentation that extends HttpInstrumentation
 * with request/response body capture
 */
-const DEFAULT_MAX_REQUEST_BODY_SIZE$1 = 4 * 1024;
-const DEFAULT_MAX_RESPONSE_BODY_SIZE$1 = 4 * 1024;
 const LEGACY_ATTR_HTTP_URL = "http.url";
 const PingopsSemanticAttributes = {
-	HTTP_REQUEST_BODY: "http.request.body",
-	HTTP_RESPONSE_BODY: "http.response.body"
+	HTTP_REQUEST_BODY,
+	HTTP_RESPONSE_BODY,
+	HTTP_REQUEST_BODY_SIZE,
+	HTTP_RESPONSE_BODY_SIZE
 };
 /**
 * Manually flattens a nested object into dot-notation keys
@@ -455,7 +924,7 @@ function isPrimitiveArray(value) {
 }
 function flatten(obj, prefix = "") {
 	const result = {};
-	for (const key in obj) if (Object.prototype.hasOwnProperty.call(obj, key)) {
+	for (const key in obj) if (Object.hasOwn(obj, key)) {
 		const newKey = prefix ? `${prefix}.${key}` : key;
 		const value = obj[key];
 		if (isPlainObject(value)) Object.assign(result, flatten(value, newKey));
@@ -474,61 +943,12 @@ function setAttributeValue(span, attrName, attrValue) {
 	} else if (isPlainObject(attrValue)) span.setAttributes(flatten({ [attrName]: attrValue }));
 }
 /**
-* Extracts domain from URL
-*/
-function extractDomainFromUrl$1(url$1) {
-	try {
-		return new URL(url$1).hostname;
-	} catch {
-		const match = url$1.match(/^(?:https?:\/\/)?([^/]+)/);
-		return match ? match[1] : "";
-	}
-}
-/**
-* Gets domain rule configuration for a given URL
-*/
-function getDomainRule$1(url$1, domainAllowList) {
-	if (!domainAllowList) return;
-	const domain = extractDomainFromUrl$1(url$1);
-	for (const rule of domainAllowList) if (domain === rule.domain || domain.endsWith(`.${rule.domain}`) || domain === rule.domain.slice(1)) return rule;
-}
-/**
-* Determines if request body should be captured based on priority:
-* context > domain rule > global config > default (false)
+* Captures request body from a chunk buffer.
 */
-function shouldCaptureRequestBody$1(url$1) {
-	const contextValue = _opentelemetry_api.context.active().getValue(_pingops_core.PINGOPS_CAPTURE_REQUEST_BODY);
-	if (contextValue !== void 0) return contextValue;
-	if (url$1) {
-		const domainRule = getDomainRule$1(url$1, getGlobalConfig()?.domainAllowList);
-		if (domainRule?.captureRequestBody !== void 0) return domainRule.captureRequestBody;
-	}
-	const globalConfig$1 = getGlobalConfig();
-	if (globalConfig$1?.captureRequestBody !== void 0) return globalConfig$1.captureRequestBody;
-	return false;
-}
-/**
-* Determines if response body should be captured based on priority:
-* context > domain rule > global config > default (false)
-*/
-function shouldCaptureResponseBody$1(url$1) {
-	const contextValue = _opentelemetry_api.context.active().getValue(_pingops_core.PINGOPS_CAPTURE_RESPONSE_BODY);
-	if (contextValue !== void 0) return contextValue;
-	if (url$1) {
-		const domainRule = getDomainRule$1(url$1, getGlobalConfig()?.domainAllowList);
-		if (domainRule?.captureResponseBody !== void 0) return domainRule.captureResponseBody;
-	}
-	const globalConfig$1 = getGlobalConfig();
-	if (globalConfig$1?.captureResponseBody !== void 0) return globalConfig$1.captureResponseBody;
-	return false;
-}
-/**
-* Captures request body from string or Buffer data
-*/
-function captureRequestBody(span, data, maxSize, semanticAttr, url$1) {
-	if (!shouldCaptureRequestBody$1(url$1)) return;
-	if (data.length && data.length <= maxSize) try {
-		const requestBody = typeof data === "string" ? data : data.toString("utf-8");
+function captureRequestBody(span, data, semanticAttr, url$1) {
+	if (!shouldCaptureRequestBody(url$1)) return;
+	if (data.length) try {
+		const requestBody = data.toString("utf-8");
 		if (requestBody) setAttributeValue(span, semanticAttr, requestBody);
 	} catch (e) {
 		console.error("Error occurred while capturing request body:", e);
@@ -537,25 +957,13 @@ function captureRequestBody(span, data, maxSize, semanticAttr, url$1) {
 /**
 * Captures response body from chunks
 */
-function captureResponseBody(span, chunks, semanticAttr, responseHeaders, url$1, maxSize) {
-	if (!shouldCaptureResponseBody$1(url$1)) return;
-	if (chunks === null) {
-		const contentEncoding = responseHeaders?.["content-encoding"];
-		const contentType = responseHeaders?.["content-type"];
-		const toHeaderString = (value) => typeof value === "string" ? value : Array.isArray(value) ? value.join(", ") : "unknown";
-		setAttributeValue(span, semanticAttr, `[truncated response body; exceeded maxResponseBodySize=${maxSize ?? DEFAULT_MAX_RESPONSE_BODY_SIZE$1}; content-type=${toHeaderString(contentType)}; content-encoding=${toHeaderString(contentEncoding)}]`);
-		return;
-	}
+function captureResponseBody(span, chunks, semanticAttr, responseHeaders, url$1) {
+	if (!shouldCaptureResponseBody(url$1)) return;
 	if (chunks.length) try {
-		const concatedChunks = Buffer.concat(chunks);
-		const contentEncoding = responseHeaders?.["content-encoding"];
-		if ((0, _pingops_core.isCompressedContentEncoding)(contentEncoding)) {
-			setAttributeValue(span, semanticAttr, concatedChunks.toString("base64"));
-			const encStr = typeof contentEncoding === "string" ? contentEncoding : Array.isArray(contentEncoding) ? contentEncoding.map(String).join(", ") : void 0;
-			if (encStr) setAttributeValue(span, _pingops_core.HTTP_RESPONSE_CONTENT_ENCODING, encStr);
-		} else {
-			const bodyStr = (0, _pingops_core.bufferToBodyString)(concatedChunks);
-			if (bodyStr != null) setAttributeValue(span, semanticAttr, bodyStr);
+		const encoded = encodeBodyBufferForSpan(Buffer.concat(chunks), responseHeaders);
+		if (encoded) {
+			setAttributeValue(span, semanticAttr, encoded.content);
+			if (encoded.contentEncoding) setAttributeValue(span, _pingops_core.HTTP_RESPONSE_CONTENT_ENCODING, encoded.contentEncoding);
 		}
 	} catch (e) {
 		console.error("Error occurred while capturing response body:", e);
@@ -632,6 +1040,7 @@ function extractClientRequestPath(request) {
 }
 const PingopsHttpSemanticAttributes = PingopsSemanticAttributes;
 var PingopsHttpInstrumentation = class extends _opentelemetry_instrumentation_http.HttpInstrumentation {
+	_llmStateByRequest = /* @__PURE__ */ new WeakMap();
 	constructor(config) {
 		super(config);
 		this._config = this._createConfig(config);
@@ -653,19 +1062,26 @@ var PingopsHttpInstrumentation = class extends _opentelemetry_instrumentation_ht
 	_createConfig(config) {
 		return {
 			...config,
-			requestHook: this._createRequestHook(config?.requestHook, config),
-			responseHook: this._createResponseHook(config?.responseHook, config)
+			requestHook: this._createRequestHook(config?.requestHook),
+			responseHook: this._createResponseHook(config?.responseHook)
 		};
 	}
-	_createRequestHook(originalRequestHook, config) {
+	_createRequestHook(originalRequestHook) {
 		return (span, request) => {
 			const headers = extractRequestHeaders(request);
 			if (headers) captureRequestHeaders(span, headers);
 			if (request instanceof http.ClientRequest) {
-				const maxRequestBodySize = config?.maxRequestBodySize || DEFAULT_MAX_REQUEST_BODY_SIZE$1;
+				let requestBodySize = 0;
+				const requestContentLength = parseContentLength(headers?.["content-length"]);
+				span.setAttribute(PingopsSemanticAttributes.HTTP_REQUEST_BODY_SIZE, requestContentLength !== void 0 ? Math.max(requestBodySize, requestContentLength) : requestBodySize);
 				const hostHeader = request.getHeader("host");
 				const host = typeof hostHeader === "string" ? hostHeader : Array.isArray(hostHeader) ? hostHeader.join(",") : typeof hostHeader === "number" ? String(hostHeader) : void 0;
 				const url$1 = request.path && host ? `${request.protocol || "http:"}//${host}${request.path}` : void 0;
+				const llmState = createLlmEnrichmentState(span, url$1, request.method, headers ?? void 0);
+				if (llmState) {
+					updateLlmRequestHeaders(llmState, headers ?? {});
+					this._llmStateByRequest.set(request, llmState);
+				}
 				if (typeof request.path === "string" && request.path.length > 0) {
 					const { path, query } = parseRequestPathAndQuery(request.path);
 					span.setAttribute(_opentelemetry_semantic_conventions.ATTR_URL_PATH, path);
@@ -675,49 +1091,68 @@ var PingopsHttpInstrumentation = class extends _opentelemetry_instrumentation_ht
 				const originalWrite = request.write.bind(request);
 				const originalEnd = request.end.bind(request);
 				request.write = ((data, ...rest) => {
-					if (typeof data === "string" || data instanceof Buffer) captureRequestBody(span, data, maxRequestBodySize, PingopsSemanticAttributes.HTTP_REQUEST_BODY, url$1);
+					const chunkBuffer = toBufferChunk(data);
+					if (chunkBuffer) {
+						requestBodySize += chunkBuffer.length;
+						span.setAttribute(PingopsSemanticAttributes.HTTP_REQUEST_BODY_SIZE, requestContentLength !== void 0 ? Math.max(requestBodySize, requestContentLength) : requestBodySize);
+						captureRequestBody(span, chunkBuffer, PingopsSemanticAttributes.HTTP_REQUEST_BODY, url$1);
+						if (llmState) appendLlmRequestChunk(llmState, chunkBuffer);
+					}
 					return originalWrite(data, ...rest);
 				});
 				request.end = ((data, ...rest) => {
-					if (typeof data === "string" || data instanceof Buffer) captureRequestBody(span, data, maxRequestBodySize, PingopsSemanticAttributes.HTTP_REQUEST_BODY, url$1);
+					const chunkBuffer = toBufferChunk(data);
+					if (chunkBuffer) {
+						requestBodySize += chunkBuffer.length;
+						span.setAttribute(PingopsSemanticAttributes.HTTP_REQUEST_BODY_SIZE, requestContentLength !== void 0 ? Math.max(requestBodySize, requestContentLength) : requestBodySize);
+						captureRequestBody(span, chunkBuffer, PingopsSemanticAttributes.HTTP_REQUEST_BODY, url$1);
+						if (llmState) appendLlmRequestChunk(llmState, chunkBuffer);
+					}
 					return originalEnd(data, ...rest);
 				});
 			}
 			if (originalRequestHook) originalRequestHook(span, request);
 		};
 	}
-	_createResponseHook(originalResponseHook, config) {
+	_createResponseHook(originalResponseHook) {
 		return (span, response) => {
 			const headers = extractResponseHeaders(response);
 			if (headers) captureResponseHeaders(span, headers);
 			if (response instanceof http.IncomingMessage) {
+				const requestForState = response.req instanceof http.ClientRequest ? response.req : void 0;
+				const llmState = requestForState ? this._llmStateByRequest.get(requestForState) : void 0;
 				const requestPath = response.req instanceof http.ClientRequest ? extractClientRequestPath(response.req) : void 0;
 				if (requestPath) {
 					const { path, query } = parseRequestPathAndQuery(requestPath);
 					span.setAttribute(_opentelemetry_semantic_conventions.ATTR_URL_PATH, path);
 					if (query) span.setAttribute(_opentelemetry_semantic_conventions.ATTR_URL_QUERY, query);
 				}
-				const maxResponseBodySize = config?.maxResponseBodySize || DEFAULT_MAX_RESPONSE_BODY_SIZE$1;
 				const url$1 = response.url || void 0;
-				let chunks = [];
+				const chunks = [];
 				let totalSize = 0;
-				const shouldCapture = shouldCaptureResponseBody$1(url$1);
+				span.setAttribute(PingopsSemanticAttributes.HTTP_RESPONSE_BODY_SIZE, 0);
+				const shouldCapture = shouldCaptureResponseBody(url$1);
+				if (llmState && headers) updateLlmResponseHeaders(llmState, headers);
 				response.prependListener("data", (chunk) => {
-					if (!chunk || !shouldCapture) return;
-					let chunkBuffer = null;
-					if (typeof chunk === "string") chunkBuffer = Buffer.from(chunk);
-					else if (Buffer.isBuffer(chunk)) chunkBuffer = chunk;
-					else if (chunk instanceof Uint8Array) chunkBuffer = Buffer.from(chunk);
+					if (!chunk) return;
+					const chunkBuffer = toBufferChunk(chunk);
 					if (!chunkBuffer) return;
 					totalSize += chunkBuffer.length;
-					if (chunks && totalSize <= maxResponseBodySize) chunks.push(chunkBuffer);
-					else chunks = null;
+					span.setAttribute(PingopsSemanticAttributes.HTTP_RESPONSE_BODY_SIZE, totalSize);
+					if (llmState) appendLlmResponseChunk(llmState, chunkBuffer);
+					if (!shouldCapture) return;
+					chunks.push(chunkBuffer);
 				});
 				let finalized = false;
 				const finalizeCapture = () => {
 					if (finalized) return;
 					finalized = true;
-					captureResponseBody(span, chunks, PingopsSemanticAttributes.HTTP_RESPONSE_BODY, headers, url$1, maxResponseBodySize);
+					const contentLength = parseContentLength(headers?.["content-length"]);
+					const responseBodySize = contentLength !== void 0 ? Math.max(totalSize, contentLength) : totalSize;
+					span.setAttribute(PingopsSemanticAttributes.HTTP_RESPONSE_BODY_SIZE, responseBodySize);
+					captureResponseBody(span, chunks, PingopsSemanticAttributes.HTTP_RESPONSE_BODY, headers, url$1);
+					if (llmState) finalizeLlmEnrichment(llmState);
+					if (requestForState) this._llmStateByRequest.delete(requestForState);
 				};
 				response.prependOnceListener("end", finalizeCapture);
 				response.prependOnceListener("close", finalizeCapture);
@@ -749,7 +1184,6 @@ function toRequestUrl$1(request) {
 * @returns PingopsHttpInstrumentation instance
 */
 function createHttpInstrumentation(config) {
-	const globalConfig$1 = getGlobalConfig();
 	const userIgnoreOutgoingRequestHook = config?.ignoreOutgoingRequestHook;
 	return new PingopsHttpInstrumentation({
 		...config,
@@ -757,67 +1191,12 @@ function createHttpInstrumentation(config) {
 		ignoreOutgoingRequestHook: (request) => {
 			if (shouldIgnoreOutboundInstrumentation(toRequestUrl$1(request))) return true;
 			return userIgnoreOutgoingRequestHook?.(request) ?? false;
-		},
-		maxRequestBodySize: globalConfig$1?.maxRequestBodySize,
-		maxResponseBodySize: globalConfig$1?.maxResponseBodySize
+		}
 	});
 }
 
 //#endregion
 //#region src/instrumentations/undici/pingops-undici.ts
-const DEFAULT_MAX_REQUEST_BODY_SIZE = 4 * 1024;
-const DEFAULT_MAX_RESPONSE_BODY_SIZE = 4 * 1024;
-const HTTP_REQUEST_BODY = "http.request.body";
-const HTTP_RESPONSE_BODY = "http.response.body";
-/**
-* Extracts domain from URL
-*/
-function extractDomainFromUrl(url$1) {
-	try {
-		return new url.URL(url$1).hostname;
-	} catch {
-		const match = url$1.match(/^(?:https?:\/\/)?([^/]+)/);
-		return match ? match[1] : "";
-	}
-}
-/**
-* Gets domain rule configuration for a given URL
-*/
-function getDomainRule(url$1, domainAllowList) {
-	if (!domainAllowList) return;
-	const domain = extractDomainFromUrl(url$1);
-	for (const rule of domainAllowList) if (domain === rule.domain || domain.endsWith(`.${rule.domain}`) || domain === rule.domain.slice(1)) return rule;
-}
-/**
-* Determines if request body should be captured based on priority:
-* context > domain rule > global config > default (false)
-*/
-function shouldCaptureRequestBody(url$1) {
-	const contextValue = _opentelemetry_api.context.active().getValue(_pingops_core.PINGOPS_CAPTURE_REQUEST_BODY);
-	if (contextValue !== void 0) return contextValue;
-	if (url$1) {
-		const domainRule = getDomainRule(url$1, getGlobalConfig()?.domainAllowList);
-		if (domainRule?.captureRequestBody !== void 0) return domainRule.captureRequestBody;
-	}
-	const globalConfig$1 = getGlobalConfig();
-	if (globalConfig$1?.captureRequestBody !== void 0) return globalConfig$1.captureRequestBody;
-	return false;
-}
-/**
-* Determines if response body should be captured based on priority:
-* context > domain rule > global config > default (false)
-*/
-function shouldCaptureResponseBody(url$1) {
-	const contextValue = _opentelemetry_api.context.active().getValue(_pingops_core.PINGOPS_CAPTURE_RESPONSE_BODY);
-	if (contextValue !== void 0) return contextValue;
-	if (url$1) {
-		const domainRule = getDomainRule(url$1, getGlobalConfig()?.domainAllowList);
-		if (domainRule?.captureResponseBody !== void 0) return domainRule.captureResponseBody;
-	}
-	const globalConfig$1 = getGlobalConfig();
-	if (globalConfig$1?.captureResponseBody !== void 0) return globalConfig$1.captureResponseBody;
-	return false;
-}
 var UndiciInstrumentation = class extends _opentelemetry_instrumentation.InstrumentationBase {
 	_recordFromReq = /* @__PURE__ */ new WeakMap();
 	constructor(config = {}) {
@@ -925,7 +1304,9 @@ var UndiciInstrumentation = class extends _opentelemetry_instrumentation.Instrum
 			[_opentelemetry_semantic_conventions.ATTR_URL_FULL]: requestUrl.toString(),
 			[_opentelemetry_semantic_conventions.ATTR_URL_PATH]: requestUrl.pathname,
 			[_opentelemetry_semantic_conventions.ATTR_URL_QUERY]: requestUrl.search,
-			[_opentelemetry_semantic_conventions.ATTR_URL_SCHEME]: urlScheme
+			[_opentelemetry_semantic_conventions.ATTR_URL_SCHEME]: urlScheme,
+			[HTTP_REQUEST_BODY_SIZE]: 0,
+			[HTTP_RESPONSE_BODY_SIZE]: 0
 		};
 		const schemePorts = {
 			https: "443",
@@ -935,7 +1316,10 @@ var UndiciInstrumentation = class extends _opentelemetry_instrumentation.Instrum
 		const serverPort = requestUrl.port || schemePorts[urlScheme];
 		attributes[_opentelemetry_semantic_conventions.ATTR_SERVER_ADDRESS] = serverAddress;
 		if (serverPort && !isNaN(Number(serverPort))) attributes[_opentelemetry_semantic_conventions.ATTR_SERVER_PORT] = Number(serverPort);
-		const userAgentValues = this.parseRequestHeaders(request).get("user-agent");
+		const headersMap = this.parseRequestHeaders(request);
+		const requestHeadersObject = {};
+		for (const [key, value] of headersMap.entries()) requestHeadersObject[key] = value;
+		const userAgentValues = headersMap.get("user-agent");
 		if (userAgentValues) attributes[_opentelemetry_semantic_conventions.ATTR_USER_AGENT_ORIGINAL] = Array.isArray(userAgentValues) ? userAgentValues[userAgentValues.length - 1] : userAgentValues;
 		const hookAttributes = (0, _opentelemetry_instrumentation.safeExecuteInTheMiddle)(() => config.startSpanHook?.(request), (e) => e && this._diag.error("caught startSpanHook error: ", e), true);
 		if (hookAttributes) Object.entries(hookAttributes).forEach(([key, val]) => {
@@ -968,13 +1352,16 @@ var UndiciInstrumentation = class extends _opentelemetry_instrumentation.Instrum
 			responseBodyChunks: [],
 			requestBodySize: 0,
 			responseBodySize: 0,
-			url: requestUrl.toString()
+			url: requestUrl.toString(),
+			llmState: createLlmEnrichmentState(span, requestUrl.toString(), request.method, requestHeadersObject)
 		});
+		const createdRecord = this._recordFromReq.get(request);
+		if (createdRecord?.llmState) updateLlmRequestHeaders(createdRecord.llmState, requestHeadersObject);
 	}
 	onRequestHeaders({ request, socket }) {
 		const record = this._recordFromReq.get(request);
 		if (!record) return;
-		const { span } = record;
+		const { span, attributes } = record;
 		const spanAttributes = {};
 		const remoteAddress = typeof socket.remoteAddress === "string" ? socket.remoteAddress : void 0;
 		const remotePort = typeof socket.remotePort === "number" ? socket.remotePort : void 0;
@@ -986,12 +1373,19 @@ var UndiciInstrumentation = class extends _opentelemetry_instrumentation.Instrum
 			spanAttributes[`http.request.header.${name}`] = attrValue;
 		}
 		span.setAttributes(spanAttributes);
+		record.attributes = Object.assign(attributes, spanAttributes);
+		if (record.llmState) {
+			const requestHeadersObject = {};
+			for (const [key, value] of headersMap.entries()) requestHeadersObject[key] = value;
+			updateLlmRequestHeaders(record.llmState, requestHeadersObject);
+		}
 	}
 	onResponseHeaders({ request, response }) {
 		const record = this._recordFromReq.get(request);
 		if (!record) return;
 		const { span, attributes } = record;
 		const spanAttributes = { [_opentelemetry_semantic_conventions.ATTR_HTTP_RESPONSE_STATUS_CODE]: response.statusCode };
+		const responseHeadersObject = {};
 		const config = this.getConfig();
 		(0, _opentelemetry_instrumentation.safeExecuteInTheMiddle)(() => config.responseHook?.(span, {
 			request,
@@ -1001,6 +1395,7 @@ var UndiciInstrumentation = class extends _opentelemetry_instrumentation.Instrum
 			const name = response.headers[idx].toString().toLowerCase();
 			const value = response.headers[idx + 1];
 			spanAttributes[`http.response.header.${name}`] = value.toString();
+			responseHeadersObject[name] = value.toString();
 			if (name === "content-length") {
 				const contentLength = Number(value.toString());
 				if (!isNaN(contentLength)) spanAttributes["http.response.header.content-length"] = contentLength;
@@ -1009,29 +1404,33 @@ var UndiciInstrumentation = class extends _opentelemetry_instrumentation.Instrum
 		span.setAttributes(spanAttributes);
 		span.setStatus({ code: response.statusCode >= 400 ? _opentelemetry_api.SpanStatusCode.ERROR : _opentelemetry_api.SpanStatusCode.UNSET });
 		record.attributes = Object.assign(attributes, spanAttributes);
+		if (record.llmState) updateLlmResponseHeaders(record.llmState, responseHeadersObject);
 	}
 	onDone({ request }) {
 		const record = this._recordFromReq.get(request);
 		if (!record) return;
 		const { span, attributes, startTime } = record;
+		const requestContentLength = parseContentLength(record.attributes?.["http.request.header.content-length"]);
+		const effectiveRequestBodySize = requestContentLength !== void 0 ? Math.max(record.requestBodySize, requestContentLength) : record.requestBodySize;
+		const responseContentLength = parseContentLength(record.attributes?.["http.response.header.content-length"]);
+		const effectiveResponseBodySize = responseContentLength !== void 0 ? Math.max(record.responseBodySize, responseContentLength) : record.responseBodySize;
+		span.setAttribute(HTTP_REQUEST_BODY_SIZE, effectiveRequestBodySize);
+		span.setAttribute(HTTP_RESPONSE_BODY_SIZE, effectiveResponseBodySize);
 		if (shouldCaptureResponseBody(record.url)) {
-			const maxResponseBodySize = this.getConfig().maxResponseBodySize ?? DEFAULT_MAX_RESPONSE_BODY_SIZE;
-			const contentEncoding = record.attributes?.["http.response.header.content-encoding"] ?? void 0;
-			const contentType = record.attributes?.["http.response.header.content-type"] ?? void 0;
-			if (record.responseBodySize === Infinity) span.setAttribute(HTTP_RESPONSE_BODY, `[truncated response body; exceeded maxResponseBodySize=${maxResponseBodySize}; content-type=${contentType ?? "unknown"}; content-encoding=${contentEncoding ?? "identity"}]`);
-			else if (record.responseBodyChunks.length > 0) try {
-				const responseBodyBuffer = Buffer.concat(record.responseBodyChunks);
-				if ((0, _pingops_core.isCompressedContentEncoding)(contentEncoding)) {
-					span.setAttribute(HTTP_RESPONSE_BODY, responseBodyBuffer.toString("base64"));
-					if (contentEncoding) span.setAttribute(_pingops_core.HTTP_RESPONSE_CONTENT_ENCODING, contentEncoding);
-				} else {
-					const bodyStr = (0, _pingops_core.bufferToBodyString)(responseBodyBuffer);
-					if (bodyStr != null) span.setAttribute(HTTP_RESPONSE_BODY, bodyStr);
+			if (record.responseBodyChunks.length > 0) try {
+				const encoded = encodeBodyBufferForSpan(Buffer.concat(record.responseBodyChunks), {
+					"content-encoding": record.attributes?.["http.response.header.content-encoding"],
+					"content-type": record.attributes?.["http.response.header.content-type"]
+				});
+				if (encoded) {
+					span.setAttribute(HTTP_RESPONSE_BODY, encoded.content);
+					if (encoded.contentEncoding) span.setAttribute(_pingops_core.HTTP_RESPONSE_CONTENT_ENCODING, encoded.contentEncoding);
 				}
 			} catch (e) {
 				this._diag.error("Error occurred while capturing response body:", e);
 			}
 		}
+		if (record.llmState) finalizeLlmEnrichment(record.llmState);
 		span.end();
 		this._recordFromReq.delete(request);
 		this.recordRequestDuration(attributes, startTime);
@@ -1040,10 +1439,19 @@ var UndiciInstrumentation = class extends _opentelemetry_instrumentation.Instrum
 		const record = this._recordFromReq.get(request);
 		if (!record) return;
 		const { span, attributes, startTime } = record;
+		const requestContentLength = parseContentLength(record.attributes?.["http.request.header.content-length"]);
+		const effectiveRequestBodySize = requestContentLength !== void 0 ? Math.max(record.requestBodySize, requestContentLength) : record.requestBodySize;
+		const responseContentLength = parseContentLength(record.attributes?.["http.response.header.content-length"]);
+		const effectiveResponseBodySize = responseContentLength !== void 0 ? Math.max(record.responseBodySize, responseContentLength) : record.responseBodySize;
+		span.setAttribute(HTTP_REQUEST_BODY_SIZE, effectiveRequestBodySize);
+		span.setAttribute(HTTP_RESPONSE_BODY_SIZE, effectiveResponseBodySize);
 		if (shouldCaptureRequestBody(record.url)) {
-			if (record.requestBodyChunks.length > 0 && record.requestBodySize !== Infinity) try {
-				const requestBody = Buffer.concat(record.requestBodyChunks).toString("utf-8");
-				if (requestBody) span.setAttribute(HTTP_REQUEST_BODY, requestBody);
+			if (record.requestBodyChunks.length > 0) try {
+				const encoded = encodeBodyBufferForSpan(Buffer.concat(record.requestBodyChunks), {
+					"content-encoding": record.attributes?.["http.request.header.content-encoding"],
+					"content-type": record.attributes?.["http.request.header.content-type"]
+				});
+				if (encoded?.content) span.setAttribute(HTTP_REQUEST_BODY, encoded.content);
 			} catch (e) {
 				this._diag.error("Error occurred while capturing request body:", e);
 			}
@@ -1054,6 +1462,7 @@ var UndiciInstrumentation = class extends _opentelemetry_instrumentation.Instrum
 			code: _opentelemetry_api.SpanStatusCode.ERROR,
 			message: errorMessage
 		});
+		if (record.llmState) finalizeLlmEnrichment(record.llmState);
 		span.end();
 		this._recordFromReq.delete(request);
 		attributes[_opentelemetry_semantic_conventions.ATTR_ERROR_TYPE] = errorMessage;
@@ -1062,29 +1471,27 @@ var UndiciInstrumentation = class extends _opentelemetry_instrumentation.Instrum
 	onBodyChunkSent({ request, chunk }) {
 		const record = this._recordFromReq.get(request);
 		if (!record) return;
+		record.requestBodySize += chunk.length;
+		if (record.llmState) appendLlmRequestChunk(record.llmState, chunk);
 		if (!shouldCaptureRequestBody(record.url)) return;
-		const maxRequestBodySize = this.getConfig().maxRequestBodySize ?? DEFAULT_MAX_REQUEST_BODY_SIZE;
-		if (record.requestBodySize + chunk.length <= maxRequestBodySize) {
-			record.requestBodyChunks.push(chunk);
-			record.requestBodySize += chunk.length;
-		} else {
-			record.requestBodySize = Infinity;
-			record.requestBodyChunks = [];
-		}
+		record.requestBodyChunks.push(chunk);
 	}
 	onBodySent({ request }) {
 		const record = this._recordFromReq.get(request);
 		if (!record) return;
+		const requestContentLength = parseContentLength(record.attributes?.["http.request.header.content-length"]);
+		const effectiveRequestBodySize = requestContentLength !== void 0 ? Math.max(record.requestBodySize, requestContentLength) : record.requestBodySize;
+		record.span.setAttribute(HTTP_REQUEST_BODY_SIZE, effectiveRequestBodySize);
 		if (!shouldCaptureRequestBody(record.url)) {
 			record.requestBodyChunks = [];
 			return;
 		}
-		if (record.requestBodySize === Infinity) {
-			const maxRequestBodySize = this.getConfig().maxRequestBodySize ?? DEFAULT_MAX_REQUEST_BODY_SIZE;
-			record.span.setAttribute(HTTP_REQUEST_BODY, `[truncated request body; exceeded maxRequestBodySize=${maxRequestBodySize}]`);
-		} else if (record.requestBodyChunks.length > 0) try {
-			const requestBody = Buffer.concat(record.requestBodyChunks).toString("utf-8");
-			if (requestBody) record.span.setAttribute(HTTP_REQUEST_BODY, requestBody);
+		if (record.requestBodyChunks.length > 0) try {
+			const encoded = encodeBodyBufferForSpan(Buffer.concat(record.requestBodyChunks), {
+				"content-encoding": record.attributes?.["http.request.header.content-encoding"],
+				"content-type": record.attributes?.["http.request.header.content-type"]
+			});
+			if (encoded?.content) record.span.setAttribute(HTTP_REQUEST_BODY, encoded.content);
 		} catch (e) {
 			this._diag.error("Error occurred while capturing request body:", e);
 		}
@@ -1093,15 +1500,10 @@ var UndiciInstrumentation = class extends _opentelemetry_instrumentation.Instrum
 	onBodyChunkReceived({ request, chunk }) {
 		const record = this._recordFromReq.get(request);
 		if (!record) return;
+		record.responseBodySize += chunk.length;
+		if (record.llmState) appendLlmResponseChunk(record.llmState, chunk);
 		if (!shouldCaptureResponseBody(record.url)) return;
-		const maxResponseBodySize = this.getConfig().maxResponseBodySize ?? DEFAULT_MAX_RESPONSE_BODY_SIZE;
-		if (record.responseBodySize + chunk.length <= maxResponseBodySize) {
-			record.responseBodyChunks.push(chunk);
-			record.responseBodySize += chunk.length;
-		} else {
-			record.responseBodySize = Infinity;
-			record.responseBodyChunks = [];
-		}
+		record.responseBodyChunks.push(chunk);
 	}
 	recordRequestDuration(attributes, startTime) {
 		const metricsAttributes = {};
@@ -1153,14 +1555,11 @@ function toRequestUrl(request) {
 * @returns UndiciInstrumentation instance
 */
 function createUndiciInstrumentation() {
-	const globalConfig$1 = getGlobalConfig();
 	return new UndiciInstrumentation({
 		enabled: true,
 		ignoreRequestHook: (request) => {
 			return shouldIgnoreOutboundInstrumentation(toRequestUrl(request));
-		},
-		maxRequestBodySize: globalConfig$1?.maxRequestBodySize,
-		maxResponseBodySize: globalConfig$1?.maxResponseBodySize
+		}
 	});
 }