@pingops/otel 0.2.1 → 0.2.2

package/dist/index.mjs

@@ -1,16 +1,16 @@
 import { BatchSpanProcessor, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { HTTP_RESPONSE_CONTENT_ENCODING, PINGOPS_CAPTURE_REQUEST_BODY, PINGOPS_CAPTURE_RESPONSE_BODY, bufferToBodyString, createLogger, extractSpanPayload, getHttpUrlFromAttributes, getPropagatedAttributesFromContext, isCompressedContentEncoding, isSpanEligible, shouldCaptureSpan } from "@pingops/core";
-import { INVALID_SPAN_CONTEXT, SpanKind, SpanStatusCode, ValueType, context, propagation, trace } from "@opentelemetry/api";
+import { INVALID_SPAN_CONTEXT, ROOT_CONTEXT, SpanKind, SpanStatusCode, ValueType, context, propagation, trace } from "@opentelemetry/api";
 import "@opentelemetry/sdk-trace-node";
 import "@opentelemetry/resources";
 import { ATTR_ERROR_TYPE, ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_REQUEST_METHOD_ORIGINAL, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_NETWORK_PEER_ADDRESS, ATTR_NETWORK_PEER_PORT, ATTR_SERVER_ADDRESS, ATTR_SERVER_PORT, ATTR_URL_FULL, ATTR_URL_PATH, ATTR_URL_QUERY, ATTR_URL_SCHEME, ATTR_USER_AGENT_ORIGINAL, METRIC_HTTP_CLIENT_REQUEST_DURATION } from "@opentelemetry/semantic-conventions";
 import { ClientRequest, IncomingMessage } from "http";
 import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
+import { hrTime, hrTimeDuration, hrTimeToMilliseconds, isTracingSuppressed } from "@opentelemetry/core";
 import * as diagch from "diagnostics_channel";
 import { URL as URL$1 } from "url";
 import { InstrumentationBase, safeExecuteInTheMiddle } from "@opentelemetry/instrumentation";
-import { hrTime, hrTimeDuration, hrTimeToMilliseconds } from "@opentelemetry/core";
 
 //#region src/config-store.ts
 let globalConfig = null;
@@ -31,7 +31,7 @@ function getGlobalConfig() {
 
 //#endregion
 //#region src/span-processor.ts
-const logger$1 = createLogger("[PingOps Processor]");
+const logger$2 = createLogger("[PingOps Processor]");
 /**
 * Creates a filtered span wrapper that applies header filtering to attributes
 *
@@ -49,7 +49,7 @@ const logger$1 = createLogger("[PingOps Processor]");
 function createFilteredSpan(span, domainAllowList, globalHeadersAllowList, globalHeadersDenyList, globalCaptureRequestBody, globalCaptureResponseBody, headerRedaction) {
 	const payload = extractSpanPayload(span, domainAllowList, globalHeadersAllowList, globalHeadersDenyList, globalCaptureRequestBody, globalCaptureResponseBody, headerRedaction);
 	const filteredAttributes = payload?.attributes ?? span.attributes;
-	logger$1.debug("Payload", { payload });
+	logger$2.debug("Payload", { payload });
 	return new Proxy(span, { get(target, prop) {
 		if (prop === "attributes") return filteredAttributes;
 		const value = target[prop];
@@ -102,9 +102,10 @@ var PingopsSpanProcessor = class {
 			captureResponseBody: config.captureResponseBody,
 			domainAllowList: config.domainAllowList,
 			maxRequestBodySize: config.maxRequestBodySize,
-			maxResponseBodySize: config.maxResponseBodySize
+			maxResponseBodySize: config.maxResponseBodySize,
+			exportTraceUrl: `${config.baseUrl}/v1/traces`
 		});
-		logger$1.info("Initialized PingopsSpanProcessor", {
+		logger$2.info("Initialized PingopsSpanProcessor", {
 			baseUrl: config.baseUrl,
 			exportMode,
 			batchSize: config.batchSize,
@@ -120,7 +121,7 @@ var PingopsSpanProcessor = class {
 	*/
 	onStart(span, parentContext) {
 		const spanContext = span.spanContext();
-		logger$1.debug("Span started", {
+		logger$2.debug("Span started", {
 			spanName: span.name,
 			spanId: spanContext.spanId,
 			traceId: spanContext.traceId
@@ -128,7 +129,7 @@ var PingopsSpanProcessor = class {
 		const propagatedAttributes = 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", {
+			logger$2.debug("Set propagated attributes on span", {
 				spanName: span.name,
 				attributeKeys: Object.keys(propagatedAttributes)
 			});
@@ -146,7 +147,7 @@ var PingopsSpanProcessor = class {
 	*/
 	onEnd(span) {
 		const spanContext = span.spanContext();
-		logger$1.debug("Span ended, processing", {
+		logger$2.debug("Span ended, processing", {
 			spanName: span.name,
 			spanId: spanContext.spanId,
 			traceId: spanContext.traceId,
@@ -154,7 +155,7 @@ var PingopsSpanProcessor = class {
 		});
 		try {
 			if (!isSpanEligible(span)) {
-				logger$1.debug("Span not eligible, skipping", {
+				logger$2.debug("Span not eligible, skipping", {
 					spanName: span.name,
 					spanId: spanContext.spanId,
 					reason: "not CLIENT or missing HTTP/GenAI attributes"
@@ -163,7 +164,7 @@ var PingopsSpanProcessor = class {
 			}
 			const attributes = span.attributes;
 			const url = getHttpUrlFromAttributes(attributes) ?? "";
-			logger$1.debug("Extracted URL for domain filtering", {
+			logger$2.debug("Extracted URL for domain filtering", {
 				spanName: span.name,
 				url,
 				hasHttpUrl: !!attributes["http.url"],
@@ -172,17 +173,17 @@ var PingopsSpanProcessor = class {
 			});
 			if (url) {
 				if (!shouldCaptureSpan(url, this.config.domainAllowList, this.config.domainDenyList)) {
-					logger$1.info("Span filtered out by domain rules", {
+					logger$2.info("Span filtered out by domain rules", {
 						spanName: span.name,
 						spanId: spanContext.spanId,
 						url
 					});
 					return;
 				}
-			} else logger$1.debug("No URL found for domain filtering, proceeding", { spanName: span.name });
+			} 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);
 			this.processor.onEnd(filteredSpan);
-			logger$1.info("Span passed all filters and queued for export", {
+			logger$2.info("Span passed all filters and queued for export", {
 				spanName: span.name,
 				spanId: spanContext.spanId,
 				traceId: spanContext.traceId,
@@ -190,7 +191,7 @@ var PingopsSpanProcessor = class {
 				hasHeaderFiltering: !!(this.config.headersAllowList || this.config.headersDenyList)
 			});
 		} catch (error) {
-			logger$1.error("Error processing span", {
+			logger$2.error("Error processing span", {
 				spanName: span.name,
 				spanId: spanContext.spanId,
 				error: error instanceof Error ? error.message : String(error)
@@ -203,12 +204,12 @@ var PingopsSpanProcessor = class {
 	* @returns Promise that resolves when all pending operations are complete
 	*/
 	async forceFlush() {
-		logger$1.info("Force flushing spans");
+		logger$2.info("Force flushing spans");
 		try {
 			await this.processor.forceFlush();
-			logger$1.info("Force flush complete");
+			logger$2.info("Force flush complete");
 		} catch (error) {
-			logger$1.error("Error during force flush", { error: error instanceof Error ? error.message : String(error) });
+			logger$2.error("Error during force flush", { error: error instanceof Error ? error.message : String(error) });
 			throw error;
 		}
 	}
@@ -218,12 +219,12 @@ var PingopsSpanProcessor = class {
 	* @returns Promise that resolves when shutdown is complete
 	*/
 	async shutdown() {
-		logger$1.info("Shutting down processor");
+		logger$2.info("Shutting down processor");
 		try {
 			await this.processor.shutdown();
-			logger$1.info("Processor shutdown complete");
+			logger$2.info("Processor shutdown complete");
 		} catch (error) {
-			logger$1.error("Error during processor shutdown", { error: error instanceof Error ? error.message : String(error) });
+			logger$2.error("Error during processor shutdown", { error: error instanceof Error ? error.message : String(error) });
 			throw error;
 		}
 	}
@@ -238,7 +239,7 @@ const PINGOPS_GLOBAL_SYMBOL = Symbol.for("pingops");
 /**
 * Logger instance for tracer provider
 */
-const logger = createLogger("[PingOps TracerProvider]");
+const logger$1 = createLogger("[PingOps TracerProvider]");
 /**
 * Creates initial global state
 */
@@ -253,21 +254,21 @@ function getGlobalState() {
 	try {
 		const g = globalThis;
 		if (typeof g !== "object" || g === null) {
-			logger.warn("globalThis is not available, using fallback state");
+			logger$1.warn("globalThis is not available, using fallback state");
 			return initialState;
 		}
 		if (!g[PINGOPS_GLOBAL_SYMBOL]) {
-			logger.debug("Creating new global state");
+			logger$1.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");
+		} else logger$1.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));
+		logger$1.error("Failed to access global state:", err instanceof Error ? err.message : String(err));
 		return initialState;
 	}
 }
@@ -285,11 +286,11 @@ function setPingopsTracerProvider(provider) {
 	const state = getGlobalState();
 	const hadProvider = state.isolatedTracerProvider !== null;
 	state.isolatedTracerProvider = provider;
-	if (provider) logger.info("Set isolated TracerProvider", {
+	if (provider) logger$1.info("Set isolated TracerProvider", {
 		hadPrevious: hadProvider,
 		providerType: provider.constructor.name
 	});
-	else logger.info("Cleared isolated TracerProvider", { hadPrevious: hadProvider });
+	else logger$1.info("Cleared isolated TracerProvider", { hadPrevious: hadProvider });
 }
 /**
 * Gets the TracerProvider for PingOps tracing operations.
@@ -303,31 +304,65 @@ function setPingopsTracerProvider(provider) {
 function getPingopsTracerProvider() {
 	const { isolatedTracerProvider } = getGlobalState();
 	if (isolatedTracerProvider) {
-		logger.debug("Using isolated TracerProvider", { providerType: isolatedTracerProvider.constructor.name });
+		logger$1.debug("Using isolated TracerProvider", { providerType: isolatedTracerProvider.constructor.name });
 		return isolatedTracerProvider;
 	}
 	const globalProvider = trace.getTracerProvider();
-	logger.debug("Using global TracerProvider", { providerType: globalProvider.constructor.name });
+	logger$1.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");
+	logger$1.info("Shutting down TracerProvider");
 	const providerWithShutdown = getPingopsTracerProvider();
 	if (providerWithShutdown && typeof providerWithShutdown.shutdown === "function") {
-		logger.debug("Calling provider.shutdown()");
+		logger$1.debug("Calling provider.shutdown()");
 		try {
 			await providerWithShutdown.shutdown();
-			logger.info("TracerProvider shutdown complete");
+			logger$1.info("TracerProvider shutdown complete");
 		} catch (error) {
-			logger.error("Error during TracerProvider shutdown:", error instanceof Error ? error.message : String(error));
+			logger$1.error("Error during TracerProvider shutdown:", error instanceof Error ? error.message : String(error));
 			throw error;
 		}
-	} else logger.warn("TracerProvider does not have shutdown method, skipping");
+	} else logger$1.warn("TracerProvider does not have shutdown method, skipping");
 	setPingopsTracerProvider(null);
-	logger.info("TracerProvider shutdown finished");
+	logger$1.info("TracerProvider shutdown finished");
+}
+
+//#endregion
+//#region src/instrumentations/suppression-guard.ts
+const logger = createLogger("[PingOps SuppressionGuard]");
+let hasLoggedSuppressionLeakWarning = false;
+function normalizeUrl(url) {
+	try {
+		return new URL(url).toString();
+	} catch {
+		return null;
+	}
+}
+function isExporterRequestUrl(requestUrl) {
+	if (!requestUrl) return false;
+	const exporterUrl = getGlobalConfig()?.exportTraceUrl;
+	if (!exporterUrl) return false;
+	const normalizedRequestUrl = normalizeUrl(requestUrl);
+	const normalizedExporterUrl = normalizeUrl(exporterUrl);
+	if (!normalizedRequestUrl || !normalizedExporterUrl) return false;
+	return normalizedRequestUrl.startsWith(normalizedExporterUrl);
+}
+/**
+* Returns a context for outbound span creation that neutralizes leaked suppression
+* for user traffic while preserving suppression for exporter requests.
+*/
+function resolveOutboundSpanParentContext(activeContext, requestUrl) {
+	if (!isTracingSuppressed(activeContext)) 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");
+		hasLoggedSuppressionLeakWarning = true;
+	} else logger.debug("Suppressed context detected for outbound user request; using ROOT_CONTEXT");
+	return ROOT_CONTEXT;
 }
 
 //#endregion
@@ -497,6 +532,20 @@ var PingopsHttpInstrumentation = class extends HttpInstrumentation {
 	constructor(config) {
 		super(config);
 		this._config = this._createConfig(config);
+		this._installOutgoingSuppressionGuard();
+	}
+	/**
+	* HttpInstrumentation's span creation is private, so we wrap the instance method
+	* to swap suppressed parent contexts with ROOT_CONTEXT for outgoing user requests.
+	*/
+	_installOutgoingSuppressionGuard() {
+		const target = this;
+		if (typeof target._startHttpSpan !== "function") return;
+		const originalStartHttpSpan = target._startHttpSpan.bind(this);
+		target._startHttpSpan = (name, options, ctx = context.active()) => {
+			if (options.kind !== SpanKind.CLIENT) return originalStartHttpSpan(name, options, ctx);
+			return originalStartHttpSpan(name, options, resolveOutboundSpanParentContext(ctx, typeof options.attributes?.["url.full"] === "string" ? options.attributes["url.full"] : void 0));
+		};
 	}
 	_createConfig(config) {
 		return {
@@ -754,16 +803,16 @@ var UndiciInstrumentation = class extends InstrumentationBase {
 		if (hookAttributes) Object.entries(hookAttributes).forEach(([key, val]) => {
 			attributes[key] = val;
 		});
-		const activeCtx = context.active();
-		const currentSpan = trace.getSpan(activeCtx);
+		const spanParentContext = resolveOutboundSpanParentContext(context.active(), requestUrl.toString());
+		const currentSpan = trace.getSpan(spanParentContext);
 		let span;
 		if (config.requireParentforSpans && (!currentSpan || !trace.isSpanContextValid(currentSpan.spanContext()))) span = trace.wrapSpanContext(INVALID_SPAN_CONTEXT);
 		else span = this.tracer.startSpan(requestMethod === "_OTHER" ? "HTTP" : requestMethod, {
 			kind: SpanKind.CLIENT,
 			attributes
-		}, activeCtx);
+		}, spanParentContext);
 		safeExecuteInTheMiddle(() => config.requestHook?.(span, request), (e) => e && this._diag.error("caught requestHook error: ", e), true);
-		const requestContext = trace.setSpan(context.active(), span);
+		const requestContext = trace.setSpan(spanParentContext, span);
 		const addedHeaders = {};
 		propagation.inject(requestContext, addedHeaders);
 		const headerEntries = Object.entries(addedHeaders);