@pingops/otel 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -0,0 +1,1018 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let _opentelemetry_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+let _opentelemetry_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
+let _pingops_core = require("@pingops/core");
+let _opentelemetry_api = require("@opentelemetry/api");
+require("@opentelemetry/sdk-trace-node");
+require("@opentelemetry/resources");
+let _opentelemetry_semantic_conventions = require("@opentelemetry/semantic-conventions");
+let http = require("http");
+let _opentelemetry_instrumentation_http = require("@opentelemetry/instrumentation-http");
+let diagnostics_channel = require("diagnostics_channel");
+diagnostics_channel = __toESM(diagnostics_channel);
+let url = require("url");
+let _opentelemetry_instrumentation = require("@opentelemetry/instrumentation");
+let _opentelemetry_core = require("@opentelemetry/core");
+
+//#region src/config-store.ts
+let globalConfig = null;
+/**
+* Sets the global processor configuration
+* @param config - Configuration to store
+*/
+function setGlobalConfig(config) {
+	globalConfig = config;
+}
+/**
+* Gets the global processor configuration
+* @returns The stored configuration or null if not set
+*/
+function getGlobalConfig() {
+	return globalConfig;
+}
+
+//#endregion
+//#region src/span-processor.ts
+const logger$1 = (0, _pingops_core.createLogger)("[PingOps Processor]");
+/**
+* Creates a filtered span wrapper that applies header filtering to attributes
+*
+* This wrapper applies both domain-specific and global header filtering:
+* - Uses domain allow list to determine domain-specific header rules
+* - Applies global header allow/deny lists
+* - Filters headers from http.request.header and http.response.header attributes
+*
+* Uses a Proxy to automatically forward all properties and methods to the original span,
+* except for 'attributes' which returns the filtered version. This approach is future-proof
+* and will work with any new methods or properties added to ReadableSpan.
+*
+* 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);
+	const filteredAttributes = payload?.attributes ?? span.attributes;
+	logger$1.debug("Payload", { payload });
+	return new Proxy(span, { get(target, prop) {
+		if (prop === "attributes") return filteredAttributes;
+		const value = target[prop];
+		if (typeof value === "function") return value.bind(target);
+		return value;
+	} });
+}
+/**
+* OpenTelemetry span processor for sending spans to PingOps backend.
+*
+* This processor wraps OpenTelemetry's built-in processors (BatchSpanProcessor or SimpleSpanProcessor)
+* and applies filtering before passing spans to the OTLP exporter.
+*/
+var PingopsSpanProcessor = class {
+	processor;
+	config;
+	/**
+	* Creates a new PingopsSpanProcessor instance.
+	*
+	* @param config - Configuration parameters for the processor
+	*/
+	constructor(config) {
+		const exportMode = config.exportMode ?? "batched";
+		const apiKey = config.apiKey || process.env.PINGOPS_API_KEY || "";
+		const exporter = new _opentelemetry_exporter_trace_otlp_http.OTLPTraceExporter({
+			url: `${config.baseUrl}/v1/traces`,
+			headers: {
+				Authorization: apiKey ? `Bearer ${apiKey}` : "",
+				"Content-Type": "application/json"
+			},
+			timeoutMillis: 5e3
+		});
+		if (exportMode === "immediate") this.processor = new _opentelemetry_sdk_trace_base.SimpleSpanProcessor(exporter);
+		else this.processor = new _opentelemetry_sdk_trace_base.BatchSpanProcessor(exporter, {
+			maxExportBatchSize: config.batchSize ?? 50,
+			scheduledDelayMillis: config.batchTimeout ?? 5e3
+		});
+		this.config = {
+			debug: config.debug ?? false,
+			headersAllowList: config.headersAllowList,
+			headersDenyList: config.headersDenyList,
+			domainAllowList: config.domainAllowList,
+			domainDenyList: config.domainDenyList,
+			captureRequestBody: config.captureRequestBody,
+			captureResponseBody: config.captureResponseBody,
+			headerRedaction: config.headerRedaction
+		};
+		setGlobalConfig({
+			captureRequestBody: config.captureRequestBody,
+			captureResponseBody: config.captureResponseBody,
+			domainAllowList: config.domainAllowList
+		});
+		logger$1.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
+		});
+	}
+	/**
+	* Called when a span starts - extracts parent attributes from context and adds them to the span
+	*/
+	onStart(span, parentContext) {
+		const spanContext = span.spanContext();
+		logger$1.debug("Span started", {
+			spanName: span.name,
+			spanId: spanContext.spanId,
+			traceId: spanContext.traceId
+		});
+		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$1.debug("Set propagated attributes on span", {
+				spanName: span.name,
+				attributeKeys: Object.keys(propagatedAttributes)
+			});
+		}
+		this.processor.onStart(span, parentContext);
+	}
+	/**
+	* Called when a span ends. Filters the span and passes it to the underlying processor if eligible.
+	*
+	* This method:
+	* 1. Checks if the span is eligible (CLIENT + HTTP/GenAI attributes)
+	* 2. Applies domain filtering (determines if span should be exported)
+	* 3. Applies header filtering via FilteredSpan wrapper (domain-specific and global rules)
+	* 4. If eligible, passes filtered span to underlying OTLP processor for export
+	*/
+	onEnd(span) {
+		const spanContext = span.spanContext();
+		logger$1.debug("Span ended, processing", {
+			spanName: span.name,
+			spanId: spanContext.spanId,
+			traceId: spanContext.traceId,
+			spanKind: span.kind
+		});
+		try {
+			if (!(0, _pingops_core.isSpanEligible)(span)) {
+				logger$1.debug("Span not eligible, skipping", {
+					spanName: span.name,
+					spanId: spanContext.spanId,
+					reason: "not CLIENT or missing HTTP/GenAI attributes"
+				});
+				return;
+			}
+			const attributes = span.attributes;
+			const url$1 = attributes["http.url"] || attributes["url.full"] || (attributes["server.address"] ? `https://${String(attributes["server.address"])}` : "");
+			logger$1.debug("Extracted URL for domain filtering", {
+				spanName: span.name,
+				url: url$1,
+				hasHttpUrl: !!attributes["http.url"],
+				hasUrlFull: !!attributes["url.full"],
+				hasServerAddress: !!attributes["server.address"]
+			});
+			if (url$1) {
+				if (!(0, _pingops_core.shouldCaptureSpan)(url$1, this.config.domainAllowList, this.config.domainDenyList)) {
+					logger$1.info("Span filtered out by domain rules", {
+						spanName: span.name,
+						spanId: spanContext.spanId,
+						url: url$1
+					});
+					return;
+				}
+			} else logger$1.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);
+			this.processor.onEnd(filteredSpan);
+			logger$1.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)
+			});
+		} catch (error) {
+			logger$1.error("Error processing span", {
+				spanName: span.name,
+				spanId: spanContext.spanId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+	/**
+	* Forces an immediate flush of all pending spans.
+	*
+	* @returns Promise that resolves when all pending operations are complete
+	*/
+	async forceFlush() {
+		logger$1.info("Force flushing spans");
+		try {
+			await this.processor.forceFlush();
+			logger$1.info("Force flush complete");
+		} catch (error) {
+			logger$1.error("Error during force flush", { error: error instanceof Error ? error.message : String(error) });
+			throw error;
+		}
+	}
+	/**
+	* Gracefully shuts down the processor, ensuring all pending operations are completed.
+	*
+	* @returns Promise that resolves when shutdown is complete
+	*/
+	async shutdown() {
+		logger$1.info("Shutting down processor");
+		try {
+			await this.processor.shutdown();
+			logger$1.info("Processor shutdown complete");
+		} catch (error) {
+			logger$1.error("Error during processor shutdown", { error: error instanceof Error ? error.message : String(error) });
+			throw error;
+		}
+	}
+};
+
+//#endregion
+//#region src/tracer-provider.ts
+/**
+* Global symbol for PingOps state
+*/
+const PINGOPS_GLOBAL_SYMBOL = Symbol.for("pingops");
+/**
+* Logger instance for tracer provider
+*/
+const logger = (0, _pingops_core.createLogger)("[PingOps TracerProvider]");
+/**
+* Creates initial global state
+*/
+function createState() {
+	return { isolatedTracerProvider: null };
+}
+/**
+* Gets the global state, creating it if it doesn't exist
+*/
+function getGlobalState() {
+	const initialState = createState();
+	try {
+		const g = globalThis;
+		if (typeof g !== "object" || g === null) {
+			logger.warn("globalThis is not available, using fallback state");
+			return initialState;
+		}
+		if (!g[PINGOPS_GLOBAL_SYMBOL]) {
+			logger.debug("Creating new global state");
+			Object.defineProperty(g, PINGOPS_GLOBAL_SYMBOL, {
+				value: initialState,
+				writable: false,
+				configurable: false,
+				enumerable: false
+			});
+		} else logger.debug("Retrieved existing global state");
+		return g[PINGOPS_GLOBAL_SYMBOL];
+	} catch (err) {
+		logger.error("Failed to access global state:", err instanceof Error ? err.message : String(err));
+		return initialState;
+	}
+}
+/**
+* Sets an isolated TracerProvider for PingOps tracing operations.
+*
+* This allows PingOps to use its own TracerProvider instance, separate from
+* the global OpenTelemetry TracerProvider. This is useful for avoiding conflicts
+* with other OpenTelemetry instrumentation in the application.
+*
+* @param provider - The TracerProvider instance to use, or null to clear the isolated provider
+* @public
+*/
+function setPingopsTracerProvider(provider) {
+	const state = getGlobalState();
+	const hadProvider = state.isolatedTracerProvider !== null;
+	state.isolatedTracerProvider = provider;
+	if (provider) logger.info("Set isolated TracerProvider", {
+		hadPrevious: hadProvider,
+		providerType: provider.constructor.name
+	});
+	else logger.info("Cleared isolated TracerProvider", { hadPrevious: hadProvider });
+}
+/**
+* Gets the TracerProvider for PingOps tracing operations.
+*
+* Returns the isolated TracerProvider if one has been set via setPingopsTracerProvider(),
+* otherwise falls back to the global OpenTelemetry TracerProvider.
+*
+* @returns The TracerProvider instance to use for PingOps tracing
+* @public
+*/
+function getPingopsTracerProvider() {
+	const { isolatedTracerProvider } = getGlobalState();
+	if (isolatedTracerProvider) {
+		logger.debug("Using isolated TracerProvider", { providerType: isolatedTracerProvider.constructor.name });
+		return isolatedTracerProvider;
+	}
+	const globalProvider = _opentelemetry_api.trace.getTracerProvider();
+	logger.debug("Using global TracerProvider", { providerType: globalProvider.constructor.name });
+	return globalProvider;
+}
+/**
+* Shuts down the TracerProvider and flushes remaining spans
+*/
+async function shutdownTracerProvider() {
+	logger.info("Shutting down TracerProvider");
+	const providerWithShutdown = getPingopsTracerProvider();
+	if (providerWithShutdown && typeof providerWithShutdown.shutdown === "function") {
+		logger.debug("Calling provider.shutdown()");
+		try {
+			await providerWithShutdown.shutdown();
+			logger.info("TracerProvider shutdown complete");
+		} catch (error) {
+			logger.error("Error during TracerProvider shutdown:", error instanceof Error ? error.message : String(error));
+			throw error;
+		}
+	} else logger.warn("TracerProvider does not have shutdown method, skipping");
+	setPingopsTracerProvider(null);
+	logger.info("TracerProvider shutdown finished");
+}
+
+//#endregion
+//#region src/instrumentations/http/pingops-http.ts
+/**
+* Pingops HTTP instrumentation that extends HttpInstrumentation
+* with request/response body capture and network timing metrics
+*/
+const DEFAULT_MAX_REQUEST_BODY_SIZE$1 = 4 * 1024;
+const DEFAULT_MAX_RESPONSE_BODY_SIZE$1 = 4 * 1024;
+const NETWORK_TIMINGS_PROP_NAME = "__networkTimings";
+const PingopsSemanticAttributes = {
+	HTTP_REQUEST_BODY: "http.request.body",
+	HTTP_RESPONSE_BODY: "http.response.body",
+	NETWORK_DNS_LOOKUP_DURATION: "net.dns.lookup.duration",
+	NETWORK_TCP_CONNECT_DURATION: "net.tcp.connect.duration",
+	NETWORK_TLS_HANDSHAKE_DURATION: "net.tls.handshake.duration",
+	NETWORK_TTFB_DURATION: "net.ttfb.duration",
+	NETWORK_CONTENT_TRANSFER_DURATION: "net.content.transfer.duration"
+};
+/**
+* Manually flattens a nested object into dot-notation keys
+*/
+function flatten(obj, prefix = "") {
+	const result = {};
+	for (const key in obj) if (Object.prototype.hasOwnProperty.call(obj, key)) {
+		const newKey = prefix ? `${prefix}.${key}` : key;
+		const value = obj[key];
+		if (value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Buffer)) Object.assign(result, flatten(value, newKey));
+		else result[newKey] = value;
+	}
+	return result;
+}
+/**
+* Sets an attribute value on a span, handling various types appropriately
+*/
+function setAttributeValue(span, attrName, attrValue) {
+	if (typeof attrValue === "string" || typeof attrValue === "number" || typeof attrValue === "boolean") span.setAttribute(attrName, attrValue);
+	else if (attrValue instanceof Buffer) span.setAttribute(attrName, attrValue.toString("utf8"));
+	else if (typeof attrValue == "object") span.setAttributes(flatten({ [attrName]: attrValue }));
+	else if (Array.isArray(attrValue)) if (attrValue.length) {
+		const firstElement = attrValue[0];
+		if (typeof firstElement === "string" || typeof firstElement === "number" || typeof firstElement === "boolean") span.setAttribute(attrName, attrValue);
+	} else span.setAttribute(attrName, attrValue);
+}
+/**
+* Processes network timings and sets them as span attributes (no spans created)
+*/
+function processNetworkTimings(span, networkTimings) {
+	if (networkTimings.startAt && networkTimings.dnsLookupAt) span.setAttribute(PingopsSemanticAttributes.NETWORK_DNS_LOOKUP_DURATION, networkTimings.dnsLookupAt - networkTimings.startAt);
+	if (networkTimings.dnsLookupAt && networkTimings.tcpConnectionAt) span.setAttribute(PingopsSemanticAttributes.NETWORK_TCP_CONNECT_DURATION, networkTimings.tcpConnectionAt - networkTimings.dnsLookupAt);
+	if (networkTimings.tcpConnectionAt && networkTimings.tlsHandshakeAt) span.setAttribute(PingopsSemanticAttributes.NETWORK_TLS_HANDSHAKE_DURATION, networkTimings.tlsHandshakeAt - networkTimings.tcpConnectionAt);
+	const startTTFB = networkTimings.tlsHandshakeAt || networkTimings.tcpConnectionAt;
+	if (networkTimings.firstByteAt && startTTFB) span.setAttribute(PingopsSemanticAttributes.NETWORK_TTFB_DURATION, networkTimings.firstByteAt - startTTFB);
+	if (networkTimings.firstByteAt && networkTimings.endAt) span.setAttribute(PingopsSemanticAttributes.NETWORK_CONTENT_TRANSFER_DURATION, networkTimings.endAt - networkTimings.firstByteAt);
+}
+/**
+* Initializes network timings on a span
+*/
+function initializeNetworkTimings(span) {
+	const networkTimings = { startAt: Date.now() };
+	Object.defineProperty(span, NETWORK_TIMINGS_PROP_NAME, {
+		enumerable: false,
+		configurable: true,
+		writable: false,
+		value: networkTimings
+	});
+	return networkTimings;
+}
+/**
+* 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)
+*/
+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");
+		if (requestBody) setAttributeValue(span, semanticAttr, requestBody);
+	} catch (e) {
+		console.error("Error occurred while capturing request body:", e);
+	}
+}
+/**
+* Captures response body from chunks
+*/
+function captureResponseBody(span, chunks, semanticAttr, url$1) {
+	if (!shouldCaptureResponseBody$1(url$1)) return;
+	if (chunks && chunks.length) try {
+		const responseBody = Buffer.concat(chunks).toString("utf8");
+		if (responseBody) setAttributeValue(span, semanticAttr, responseBody);
+	} catch (e) {
+		console.error("Error occurred while capturing response body:", e);
+	}
+}
+/**
+* Captures HTTP request headers as span attributes
+*/
+function captureRequestHeaders(span, headers) {
+	for (const [key, value] of Object.entries(headers)) if (value !== void 0) span.setAttribute(`pingops.http.request.header.${key.toLowerCase()}`, Array.isArray(value) ? value.join(",") : String(value));
+}
+/**
+* Captures HTTP response headers as span attributes
+*/
+function captureResponseHeaders(span, headers) {
+	for (const [key, value] of Object.entries(headers)) if (value !== void 0) span.setAttribute(`pingops.http.response.header.${key.toLowerCase()}`, Array.isArray(value) ? value.join(",") : String(value));
+}
+const PingopsHttpSemanticAttributes = PingopsSemanticAttributes;
+var PingopsHttpInstrumentation = class extends _opentelemetry_instrumentation_http.HttpInstrumentation {
+	constructor(config) {
+		super(config);
+		this._config = this._createConfig(config);
+	}
+	_createConfig(config) {
+		return {
+			...config,
+			requestHook: this._createRequestHook(config?.requestHook, config),
+			responseHook: this._createResponseHook(config?.responseHook, config)
+		};
+	}
+	_createRequestHook(originalRequestHook, config) {
+		return (span, request) => {
+			const headers = request.headers;
+			if (headers) captureRequestHeaders(span, headers);
+			if (request instanceof http.ClientRequest) {
+				const networkTimings = initializeNetworkTimings(span);
+				const maxRequestBodySize = config?.maxRequestBodySize || DEFAULT_MAX_REQUEST_BODY_SIZE$1;
+				const url$1 = request.path && request.getHeader("host") ? `${request.protocol || "http:"}//${request.getHeader("host")}${request.path}` : void 0;
+				const originalWrite = request.write.bind(request);
+				const originalEnd = request.end.bind(request);
+				request.write = (data) => {
+					if (typeof data === "string" || data instanceof Buffer) captureRequestBody(span, data, maxRequestBodySize, PingopsSemanticAttributes.HTTP_REQUEST_BODY, url$1);
+					return originalWrite(data);
+				};
+				request.end = (data) => {
+					if (typeof data === "string" || data instanceof Buffer) captureRequestBody(span, data, maxRequestBodySize, PingopsSemanticAttributes.HTTP_REQUEST_BODY, url$1);
+					return originalEnd(data);
+				};
+				request.on("socket", (socket) => {
+					socket.on("lookup", () => {
+						networkTimings.dnsLookupAt = Date.now();
+					});
+					socket.on("connect", () => {
+						networkTimings.tcpConnectionAt = Date.now();
+					});
+					socket.on("secureConnect", () => {
+						networkTimings.tlsHandshakeAt = Date.now();
+					});
+				});
+			}
+			if (originalRequestHook) originalRequestHook(span, request);
+		};
+	}
+	_createResponseHook(originalResponseHook, config) {
+		return (span, response) => {
+			const headers = response.headers;
+			if (headers) captureResponseHeaders(span, headers);
+			if (response instanceof http.IncomingMessage) {
+				const networkTimings = span[NETWORK_TIMINGS_PROP_NAME];
+				const maxResponseBodySize = config?.maxResponseBodySize || DEFAULT_MAX_RESPONSE_BODY_SIZE$1;
+				const url$1 = response.url || void 0;
+				let chunks = [];
+				let totalSize = 0;
+				const shouldCapture = shouldCaptureResponseBody$1(url$1);
+				response.prependListener("data", (chunk) => {
+					if (!chunk || !shouldCapture) return;
+					if (typeof chunk === "string" || chunk instanceof Buffer) {
+						totalSize += chunk.length;
+						if (chunks && totalSize <= maxResponseBodySize) chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+						else chunks = null;
+					}
+				});
+				response.prependOnceListener("end", () => {
+					if (networkTimings) {
+						networkTimings.endAt = Date.now();
+						processNetworkTimings(span, networkTimings);
+					}
+					captureResponseBody(span, chunks, PingopsSemanticAttributes.HTTP_RESPONSE_BODY, url$1);
+				});
+				if (networkTimings) response.once("readable", () => {
+					networkTimings.firstByteAt = Date.now();
+				});
+			}
+			if (originalResponseHook) originalResponseHook(span, response);
+		};
+	}
+};
+
+//#endregion
+//#region src/instrumentations/http/http.ts
+/**
+* HTTP instrumentation for OpenTelemetry
+*/
+/**
+* Creates an HTTP instrumentation instance
+*
+* @param isGlobalInstrumentationEnabled - Function that checks if global instrumentation is enabled
+* @param config - Optional configuration for the instrumentation
+* @returns PingopsHttpInstrumentation instance
+*/
+function createHttpInstrumentation(isGlobalInstrumentationEnabled, config) {
+	return new PingopsHttpInstrumentation({
+		ignoreIncomingRequestHook: () => true,
+		ignoreOutgoingRequestHook: () => {
+			if (isGlobalInstrumentationEnabled()) return false;
+			return _opentelemetry_api.context.active().getValue(_pingops_core.PINGOPS_HTTP_ENABLED) !== true;
+		},
+		...config
+	});
+}
+
+//#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 = {}) {
+		super("pingops-undici", "0.1.0", config);
+	}
+	init() {}
+	disable() {
+		super.disable();
+		this._channelSubs.forEach((sub) => sub.unsubscribe());
+		this._channelSubs.length = 0;
+	}
+	enable() {
+		super.enable();
+		this._channelSubs = this._channelSubs || [];
+		if (this._channelSubs.length > 0) return;
+		this.subscribeToChannel("undici:request:create", this.onRequestCreated.bind(this));
+		this.subscribeToChannel("undici:client:sendHeaders", this.onRequestHeaders.bind(this));
+		this.subscribeToChannel("undici:request:headers", this.onResponseHeaders.bind(this));
+		this.subscribeToChannel("undici:request:trailers", this.onDone.bind(this));
+		this.subscribeToChannel("undici:request:error", this.onError.bind(this));
+		this.subscribeToChannel("undici:request:bodyChunkSent", this.onBodyChunkSent.bind(this));
+		this.subscribeToChannel("undici:request:bodySent", this.onBodySent.bind(this));
+		this.subscribeToChannel("undici:request:bodyChunkReceived", this.onBodyChunkReceived.bind(this));
+	}
+	_updateMetricInstruments() {
+		this._httpClientDurationHistogram = this.meter.createHistogram(_opentelemetry_semantic_conventions.METRIC_HTTP_CLIENT_REQUEST_DURATION, {
+			description: "Measures the duration of outbound HTTP requests.",
+			unit: "s",
+			valueType: _opentelemetry_api.ValueType.DOUBLE,
+			advice: { explicitBucketBoundaries: [
+				.005,
+				.01,
+				.025,
+				.05,
+				.075,
+				.1,
+				.25,
+				.5,
+				.75,
+				1,
+				2.5,
+				5,
+				7.5,
+				10
+			] }
+		});
+	}
+	subscribeToChannel(diagnosticChannel, onMessage) {
+		const [major, minor] = process.version.replace("v", "").split(".").map((n) => Number(n));
+		const useNewSubscribe = major > 18 || major === 18 && minor >= 19;
+		let unsubscribe;
+		if (useNewSubscribe) {
+			diagnostics_channel.subscribe?.(diagnosticChannel, onMessage);
+			unsubscribe = () => diagnostics_channel.unsubscribe?.(diagnosticChannel, onMessage);
+		} else {
+			const channel = diagnostics_channel.channel(diagnosticChannel);
+			channel.subscribe(onMessage);
+			unsubscribe = () => channel.unsubscribe(onMessage);
+		}
+		this._channelSubs.push({
+			name: diagnosticChannel,
+			unsubscribe
+		});
+	}
+	parseRequestHeaders(request) {
+		const result = /* @__PURE__ */ new Map();
+		if (Array.isArray(request.headers)) for (let i = 0; i < request.headers.length; i += 2) {
+			const key = request.headers[i];
+			const value = request.headers[i + 1];
+			if (typeof key === "string") result.set(key.toLowerCase(), value);
+		}
+		else if (typeof request.headers === "string") {
+			const headers = request.headers.split("\r\n");
+			for (const line of headers) {
+				if (!line) continue;
+				const colonIndex = line.indexOf(":");
+				if (colonIndex === -1) continue;
+				const key = line.substring(0, colonIndex).toLowerCase();
+				const value = line.substring(colonIndex + 1).trim();
+				const allValues = result.get(key);
+				if (allValues && Array.isArray(allValues)) allValues.push(value);
+				else if (allValues) result.set(key, [allValues, value]);
+				else result.set(key, value);
+			}
+		}
+		return result;
+	}
+	onRequestCreated({ request }) {
+		const config = this.getConfig();
+		const enabled = config.enabled !== false;
+		if ((0, _opentelemetry_instrumentation.safeExecuteInTheMiddle)(() => !enabled || request.method === "CONNECT" || config.ignoreRequestHook?.(request), (e) => e && this._diag.error("caught ignoreRequestHook error: ", e), true)) return;
+		const startTime = (0, _opentelemetry_core.hrTime)();
+		let requestUrl;
+		try {
+			requestUrl = new url.URL(request.path, request.origin);
+		} catch (err) {
+			this._diag.warn("could not determine url.full:", err);
+			return;
+		}
+		const urlScheme = requestUrl.protocol.replace(":", "");
+		const requestMethod = this.getRequestMethod(request.method);
+		const attributes = {
+			[_opentelemetry_semantic_conventions.ATTR_HTTP_REQUEST_METHOD]: requestMethod,
+			[_opentelemetry_semantic_conventions.ATTR_HTTP_REQUEST_METHOD_ORIGINAL]: request.method,
+			[_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
+		};
+		const schemePorts = {
+			https: "443",
+			http: "80"
+		};
+		const serverAddress = requestUrl.hostname;
+		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");
+		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]) => {
+			attributes[key] = val;
+		});
+		const activeCtx = _opentelemetry_api.context.active();
+		const currentSpan = _opentelemetry_api.trace.getSpan(activeCtx);
+		let span;
+		if (config.requireParentforSpans && (!currentSpan || !_opentelemetry_api.trace.isSpanContextValid(currentSpan.spanContext()))) span = _opentelemetry_api.trace.wrapSpanContext(_opentelemetry_api.INVALID_SPAN_CONTEXT);
+		else span = this.tracer.startSpan(requestMethod === "_OTHER" ? "HTTP" : requestMethod, {
+			kind: _opentelemetry_api.SpanKind.CLIENT,
+			attributes
+		}, activeCtx);
+		(0, _opentelemetry_instrumentation.safeExecuteInTheMiddle)(() => config.requestHook?.(span, request), (e) => e && this._diag.error("caught requestHook error: ", e), true);
+		const requestContext = _opentelemetry_api.trace.setSpan(_opentelemetry_api.context.active(), span);
+		const addedHeaders = {};
+		_opentelemetry_api.propagation.inject(requestContext, addedHeaders);
+		const headerEntries = Object.entries(addedHeaders);
+		for (let i = 0; i < headerEntries.length; i++) {
+			const [k, v] = headerEntries[i];
+			if (typeof request.addHeader === "function") request.addHeader(k, v);
+			else if (typeof request.headers === "string") request.headers += `${k}: ${v}\r\n`;
+			else if (Array.isArray(request.headers)) request.headers.push(k, v);
+		}
+		this._recordFromReq.set(request, {
+			span,
+			attributes,
+			startTime,
+			requestBodyChunks: [],
+			responseBodyChunks: [],
+			requestBodySize: 0,
+			responseBodySize: 0,
+			url: requestUrl.toString()
+		});
+	}
+	onRequestHeaders({ request, socket }) {
+		const record = this._recordFromReq.get(request);
+		if (!record) return;
+		const { span } = record;
+		const { remoteAddress, remotePort } = socket;
+		const spanAttributes = {
+			[_opentelemetry_semantic_conventions.ATTR_NETWORK_PEER_ADDRESS]: remoteAddress,
+			[_opentelemetry_semantic_conventions.ATTR_NETWORK_PEER_PORT]: remotePort
+		};
+		const headersMap = this.parseRequestHeaders(request);
+		for (const [name, value] of headersMap.entries()) {
+			const attrValue = Array.isArray(value) ? value.join(", ") : value;
+			spanAttributes[`http.request.header.${name}`] = attrValue;
+		}
+		span.setAttributes(spanAttributes);
+	}
+	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 config = this.getConfig();
+		(0, _opentelemetry_instrumentation.safeExecuteInTheMiddle)(() => config.responseHook?.(span, {
+			request,
+			response
+		}), (e) => e && this._diag.error("caught responseHook error: ", e), true);
+		for (let idx = 0; idx < response.headers.length; idx = idx + 2) {
+			const name = response.headers[idx].toString().toLowerCase();
+			const value = response.headers[idx + 1];
+			spanAttributes[`http.response.header.${name}`] = value.toString();
+			if (name === "content-length") {
+				const contentLength = Number(value.toString());
+				if (!isNaN(contentLength)) spanAttributes["http.response.header.content-length"] = contentLength;
+			}
+		}
+		span.setAttributes(spanAttributes);
+		span.setStatus({ code: response.statusCode >= 400 ? _opentelemetry_api.SpanStatusCode.ERROR : _opentelemetry_api.SpanStatusCode.UNSET });
+		record.attributes = Object.assign(attributes, spanAttributes);
+	}
+	onDone({ request }) {
+		const record = this._recordFromReq.get(request);
+		if (!record) return;
+		const { span, attributes, startTime } = record;
+		if (shouldCaptureResponseBody(record.url)) {
+			if (record.responseBodyChunks.length > 0 && record.responseBodySize !== Infinity) try {
+				const responseBody = Buffer.concat(record.responseBodyChunks).toString("utf-8");
+				if (responseBody) span.setAttribute(HTTP_RESPONSE_BODY, responseBody);
+			} catch (e) {
+				this._diag.error("Error occurred while capturing response body:", e);
+			}
+		}
+		span.end();
+		this._recordFromReq.delete(request);
+		this.recordRequestDuration(attributes, startTime);
+	}
+	onError({ request, error }) {
+		const record = this._recordFromReq.get(request);
+		if (!record) return;
+		const { span, attributes, startTime } = record;
+		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);
+			} catch (e) {
+				this._diag.error("Error occurred while capturing request body:", e);
+			}
+		}
+		span.recordException(error);
+		span.setStatus({
+			code: _opentelemetry_api.SpanStatusCode.ERROR,
+			message: error.message
+		});
+		span.end();
+		this._recordFromReq.delete(request);
+		attributes[_opentelemetry_semantic_conventions.ATTR_ERROR_TYPE] = error.message;
+		this.recordRequestDuration(attributes, startTime);
+	}
+	onBodyChunkSent({ request, chunk }) {
+		const record = this._recordFromReq.get(request);
+		if (!record) return;
+		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 if (record.requestBodyChunks.length === 0) record.requestBodySize = Infinity;
+	}
+	onBodySent({ request }) {
+		const record = this._recordFromReq.get(request);
+		if (!record) return;
+		if (!shouldCaptureRequestBody(record.url)) {
+			record.requestBodyChunks = [];
+			return;
+		}
+		if (record.requestBodyChunks.length > 0 && record.requestBodySize !== Infinity) try {
+			const requestBody = Buffer.concat(record.requestBodyChunks).toString("utf-8");
+			if (requestBody) record.span.setAttribute(HTTP_REQUEST_BODY, requestBody);
+		} catch (e) {
+			this._diag.error("Error occurred while capturing request body:", e);
+		}
+		record.requestBodyChunks = [];
+	}
+	onBodyChunkReceived({ request, chunk }) {
+		const record = this._recordFromReq.get(request);
+		if (!record) return;
+		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 if (record.responseBodyChunks.length === 0) record.responseBodySize = Infinity;
+	}
+	recordRequestDuration(attributes, startTime) {
+		const metricsAttributes = {};
+		[
+			_opentelemetry_semantic_conventions.ATTR_HTTP_RESPONSE_STATUS_CODE,
+			_opentelemetry_semantic_conventions.ATTR_HTTP_REQUEST_METHOD,
+			_opentelemetry_semantic_conventions.ATTR_SERVER_ADDRESS,
+			_opentelemetry_semantic_conventions.ATTR_SERVER_PORT,
+			_opentelemetry_semantic_conventions.ATTR_URL_SCHEME,
+			_opentelemetry_semantic_conventions.ATTR_ERROR_TYPE
+		].forEach((key) => {
+			if (key in attributes) metricsAttributes[key] = attributes[key];
+		});
+		const durationSeconds = (0, _opentelemetry_core.hrTimeToMilliseconds)((0, _opentelemetry_core.hrTimeDuration)(startTime, (0, _opentelemetry_core.hrTime)())) / 1e3;
+		this._httpClientDurationHistogram.record(durationSeconds, metricsAttributes);
+	}
+	getRequestMethod(original) {
+		if (original.toUpperCase() in {
+			CONNECT: true,
+			OPTIONS: true,
+			HEAD: true,
+			GET: true,
+			POST: true,
+			PUT: true,
+			PATCH: true,
+			DELETE: true,
+			TRACE: true
+		}) return original.toUpperCase();
+		return "_OTHER";
+	}
+};
+
+//#endregion
+//#region src/instrumentations/undici/undici.ts
+/**
+* Undici instrumentation for OpenTelemetry
+*/
+/**
+* Creates an Undici instrumentation instance
+*
+* @param isGlobalInstrumentationEnabled - Function that checks if global instrumentation is enabled
+* @returns UndiciInstrumentation instance
+*/
+function createUndiciInstrumentation(isGlobalInstrumentationEnabled) {
+	return new UndiciInstrumentation({
+		enabled: true,
+		ignoreRequestHook: () => {
+			if (isGlobalInstrumentationEnabled()) return false;
+			return _opentelemetry_api.context.active().getValue(_pingops_core.PINGOPS_HTTP_ENABLED) !== true;
+		}
+	});
+}
+
+//#endregion
+//#region src/instrumentations/index.ts
+let installed = false;
+/**
+* Registers instrumentations for Node.js environment.
+* This function is idempotent and can be called multiple times safely.
+*
+* Instrumentation behavior:
+* - If global instrumentation is enabled: all HTTP requests are instrumented
+* - If global instrumentation is NOT enabled: only requests within wrapHttp blocks are instrumented
+*
+* @param isGlobalInstrumentationEnabled - Function that checks if global instrumentation is enabled
+* @returns Array of Instrumentation instances
+*/
+function getInstrumentations(isGlobalInstrumentationEnabled) {
+	if (installed) return [];
+	installed = true;
+	return [createHttpInstrumentation(isGlobalInstrumentationEnabled), createUndiciInstrumentation(isGlobalInstrumentationEnabled)];
+}
+
+//#endregion
+exports.PingopsHttpInstrumentation = PingopsHttpInstrumentation;
+exports.PingopsHttpSemanticAttributes = PingopsHttpSemanticAttributes;
+exports.PingopsSemanticAttributes = PingopsSemanticAttributes;
+exports.PingopsSpanProcessor = PingopsSpanProcessor;
+exports.createHttpInstrumentation = createHttpInstrumentation;
+exports.createUndiciInstrumentation = createUndiciInstrumentation;
+exports.getInstrumentations = getInstrumentations;
+exports.getPingopsTracerProvider = getPingopsTracerProvider;
+exports.setPingopsTracerProvider = setPingopsTracerProvider;
+exports.shutdownTracerProvider = shutdownTracerProvider;
+//# sourceMappingURL=index.cjs.map