@pingops/otel 0.2.3 → 0.2.5

package/dist/index.cjs

@@ -60,6 +60,21 @@ function getGlobalConfig() {
 //#endregion
 //#region src/span-processor.ts
 const logger$2 = (0, _pingops_core.createLogger)("[PingOps Processor]");
+function normalizePath$1(pathname) {
+	return pathname.replace(/\/+/g, "/").replace(/\/$/, "");
+}
+function isExporterRequestUrl$1(url$1, exporterUrl) {
+	try {
+		const request = new URL(url$1);
+		const exporter = new URL(exporterUrl);
+		if (request.origin !== exporter.origin) return false;
+		const requestPath = normalizePath$1(request.pathname);
+		const exporterPath = normalizePath$1(exporter.pathname);
+		return requestPath === exporterPath || requestPath.startsWith(`${exporterPath}/`);
+	} catch {
+		return false;
+	}
+}
 /**
 * Creates a filtered span wrapper that applies header filtering to attributes
 *
@@ -93,6 +108,7 @@ function createFilteredSpan(span, domainAllowList, globalHeadersAllowList, globa
 */
 var PingopsSpanProcessor = class {
 	processor;
+	exporterTraceUrl;
 	config;
 	/**
 	* Creates a new PingopsSpanProcessor instance.
@@ -102,8 +118,9 @@ var PingopsSpanProcessor = class {
 	constructor(config) {
 		const exportMode = config.exportMode ?? "batched";
 		const apiKey = config.apiKey || process.env.PINGOPS_API_KEY || "";
+		this.exporterTraceUrl = `${config.baseUrl}/v1/traces`;
 		const exporter = new _opentelemetry_exporter_trace_otlp_http.OTLPTraceExporter({
-			url: `${config.baseUrl}/v1/traces`,
+			url: this.exporterTraceUrl,
 			headers: {
 				Authorization: apiKey ? `Bearer ${apiKey}` : "",
 				"Content-Type": "application/json"
@@ -131,7 +148,7 @@ var PingopsSpanProcessor = class {
 			domainAllowList: config.domainAllowList,
 			maxRequestBodySize: config.maxRequestBodySize,
 			maxResponseBodySize: config.maxResponseBodySize,
-			exportTraceUrl: `${config.baseUrl}/v1/traces`
+			exportTraceUrl: this.exporterTraceUrl
 		});
 		logger$2.info("Initialized PingopsSpanProcessor", {
 			baseUrl: config.baseUrl,
@@ -192,6 +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", {
+					spanName: span.name,
+					spanId: spanContext.spanId,
+					url: url$1
+				});
+				return;
+			}
 			logger$2.debug("Extracted URL for domain filtering", {
 				spanName: span.name,
 				url: url$1,
@@ -363,9 +388,12 @@ async function shutdownTracerProvider() {
 //#region src/instrumentations/suppression-guard.ts
 const logger = (0, _pingops_core.createLogger)("[PingOps SuppressionGuard]");
 let hasLoggedSuppressionLeakWarning = false;
-function normalizeUrl(url$1) {
+function normalizePath(pathname) {
+	return pathname.replace(/\/+/g, "/").replace(/\/$/, "");
+}
+function parseUrl(url$1) {
 	try {
-		return new URL(url$1).toString();
+		return new URL(url$1);
 	} catch {
 		return null;
 	}
@@ -374,10 +402,20 @@ 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);
+	const parsedRequestUrl = parseUrl(requestUrl);
+	const parsedExporterUrl = parseUrl(exporterUrl);
+	if (!parsedRequestUrl || !parsedExporterUrl) return false;
+	if (parsedRequestUrl.origin !== parsedExporterUrl.origin) return false;
+	const requestPath = normalizePath(parsedRequestUrl.pathname);
+	const exporterPath = normalizePath(parsedExporterUrl.pathname);
+	return requestPath === exporterPath || requestPath.startsWith(`${exporterPath}/`);
+}
+/**
+* Determines whether an outbound request should be skipped from instrumentation
+* to prevent exporter self-instrumentation loops.
+*/
+function shouldIgnoreOutboundInstrumentation(requestUrl) {
+	return isExporterRequestUrl(requestUrl);
 }
 /**
 * Returns a context for outbound span creation that neutralizes leaked suppression
@@ -401,6 +439,7 @@ function resolveOutboundSpanParentContext(activeContext, requestUrl) {
 */
 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"
@@ -408,12 +447,18 @@ const PingopsSemanticAttributes = {
 /**
 * Manually flattens a nested object into dot-notation keys
 */
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Buffer);
+}
+function isPrimitiveArray(value) {
+	return value.every((item) => typeof item === "string" || typeof item === "number" || typeof item === "boolean");
+}
 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));
+		if (isPlainObject(value)) Object.assign(result, flatten(value, newKey));
 		else result[newKey] = value;
 	}
 	return result;
@@ -424,11 +469,9 @@ function flatten(obj, prefix = "") {
 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);
+	else if (Array.isArray(attrValue)) {
+		if (attrValue.length === 0 || isPrimitiveArray(attrValue)) span.setAttribute(attrName, attrValue);
+	} else if (isPlainObject(attrValue)) span.setAttributes(flatten({ [attrName]: attrValue }));
 }
 /**
 * Extracts domain from URL
@@ -494,9 +537,16 @@ function captureRequestBody(span, data, maxSize, semanticAttr, url$1) {
 /**
 * Captures response body from chunks
 */
-function captureResponseBody(span, chunks, semanticAttr, responseHeaders, url$1) {
+function captureResponseBody(span, chunks, semanticAttr, responseHeaders, url$1, maxSize) {
 	if (!shouldCaptureResponseBody$1(url$1)) return;
-	if (chunks && chunks.length) try {
+	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;
+	}
+	if (chunks.length) try {
 		const concatedChunks = Buffer.concat(chunks);
 		const contentEncoding = responseHeaders?.["content-encoding"];
 		if ((0, _pingops_core.isCompressedContentEncoding)(contentEncoding)) {
@@ -559,7 +609,7 @@ function extractRequestUrlFromSpanOptions(options) {
 	const attrs = options.attributes;
 	if (!attrs) return;
 	if (typeof attrs[_opentelemetry_semantic_conventions.ATTR_URL_FULL] === "string") return attrs[_opentelemetry_semantic_conventions.ATTR_URL_FULL];
-	if (typeof attrs[_opentelemetry_semantic_conventions.ATTR_HTTP_URL] === "string") return attrs[_opentelemetry_semantic_conventions.ATTR_HTTP_URL];
+	if (typeof attrs[LEGACY_ATTR_HTTP_URL] === "string") return attrs[LEGACY_ATTR_HTTP_URL];
 	const scheme = typeof attrs[_opentelemetry_semantic_conventions.ATTR_URL_SCHEME] === "string" ? attrs[_opentelemetry_semantic_conventions.ATTR_URL_SCHEME] : "http";
 	const host = typeof attrs[_opentelemetry_semantic_conventions.ATTR_SERVER_ADDRESS] === "string" ? attrs[_opentelemetry_semantic_conventions.ATTR_SERVER_ADDRESS] : void 0;
 	if (!host) return;
@@ -598,17 +648,19 @@ var PingopsHttpInstrumentation = class extends _opentelemetry_instrumentation_ht
 			if (headers) captureRequestHeaders(span, headers);
 			if (request instanceof http.ClientRequest) {
 				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 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 originalWrite = request.write.bind(request);
 				const originalEnd = request.end.bind(request);
-				request.write = (data) => {
+				request.write = ((data, ...rest) => {
 					if (typeof data === "string" || data instanceof Buffer) captureRequestBody(span, data, maxRequestBodySize, PingopsSemanticAttributes.HTTP_REQUEST_BODY, url$1);
-					return originalWrite(data);
-				};
-				request.end = (data) => {
+					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);
-					return originalEnd(data);
-				};
+					return originalEnd(data, ...rest);
+				});
 			}
 			if (originalRequestHook) originalRequestHook(span, request);
 		};
@@ -625,15 +677,24 @@ var PingopsHttpInstrumentation = class extends _opentelemetry_instrumentation_ht
 				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", () => {
-					captureResponseBody(span, chunks, PingopsSemanticAttributes.HTTP_RESPONSE_BODY, headers, url$1);
+					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 (!chunkBuffer) return;
+					totalSize += chunkBuffer.length;
+					if (chunks && totalSize <= maxResponseBodySize) chunks.push(chunkBuffer);
+					else chunks = null;
 				});
+				let finalized = false;
+				const finalizeCapture = () => {
+					if (finalized) return;
+					finalized = true;
+					captureResponseBody(span, chunks, PingopsSemanticAttributes.HTTP_RESPONSE_BODY, headers, url$1, maxResponseBodySize);
+				};
+				response.prependOnceListener("end", finalizeCapture);
+				response.prependOnceListener("close", finalizeCapture);
+				response.prependOnceListener("aborted", finalizeCapture);
 			}
 			if (originalResponseHook) originalResponseHook(span, response);
 		};
@@ -645,6 +706,14 @@ var PingopsHttpInstrumentation = class extends _opentelemetry_instrumentation_ht
 /**
 * HTTP instrumentation for OpenTelemetry
 */
+function toRequestUrl$1(request) {
+	if (typeof request.href === "string" && request.href.length > 0) return request.href;
+	const protocol = typeof request.protocol === "string" && request.protocol.length > 0 ? request.protocol : "http:";
+	const hostnameOrHost = typeof request.hostname === "string" && request.hostname.length > 0 ? request.hostname : request.host;
+	if (!hostnameOrHost) return;
+	const hasPortInHost = hostnameOrHost.includes(":");
+	return `${protocol}//${hostnameOrHost}${request.port != null && !hasPortInHost ? `:${request.port}` : ""}${typeof request.path === "string" ? request.path : typeof request.pathname === "string" ? request.pathname : "/"}`;
+}
 /**
 * Creates an HTTP instrumentation instance.
 * All outgoing HTTP requests are instrumented when the SDK is initialized.
@@ -654,12 +723,16 @@ var PingopsHttpInstrumentation = class extends _opentelemetry_instrumentation_ht
 */
 function createHttpInstrumentation(config) {
 	const globalConfig$1 = getGlobalConfig();
+	const userIgnoreOutgoingRequestHook = config?.ignoreOutgoingRequestHook;
 	return new PingopsHttpInstrumentation({
+		...config,
 		ignoreIncomingRequestHook: () => true,
-		ignoreOutgoingRequestHook: () => false,
+		ignoreOutgoingRequestHook: (request) => {
+			if (shouldIgnoreOutboundInstrumentation(toRequestUrl$1(request))) return true;
+			return userIgnoreOutgoingRequestHook?.(request) ?? false;
+		},
 		maxRequestBodySize: globalConfig$1?.maxRequestBodySize,
-		maxResponseBodySize: globalConfig$1?.maxResponseBodySize,
-		...config
+		maxResponseBodySize: globalConfig$1?.maxResponseBodySize
 	});
 }
 
@@ -875,11 +948,11 @@ var UndiciInstrumentation = class extends _opentelemetry_instrumentation.Instrum
 		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 spanAttributes = {};
+		const remoteAddress = typeof socket.remoteAddress === "string" ? socket.remoteAddress : void 0;
+		const remotePort = typeof socket.remotePort === "number" ? socket.remotePort : void 0;
+		if (remoteAddress) spanAttributes[_opentelemetry_semantic_conventions.ATTR_NETWORK_PEER_ADDRESS] = remoteAddress;
+		if (remotePort !== void 0) spanAttributes[_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;
@@ -948,14 +1021,15 @@ var UndiciInstrumentation = class extends _opentelemetry_instrumentation.Instrum
 				this._diag.error("Error occurred while capturing request body:", e);
 			}
 		}
+		const errorMessage = error.message;
 		span.recordException(error);
 		span.setStatus({
 			code: _opentelemetry_api.SpanStatusCode.ERROR,
-			message: error.message
+			message: errorMessage
 		});
 		span.end();
 		this._recordFromReq.delete(request);
-		attributes[_opentelemetry_semantic_conventions.ATTR_ERROR_TYPE] = error.message;
+		attributes[_opentelemetry_semantic_conventions.ATTR_ERROR_TYPE] = errorMessage;
 		this.recordRequestDuration(attributes, startTime);
 	}
 	onBodyChunkSent({ request, chunk }) {
@@ -1038,6 +1112,13 @@ var UndiciInstrumentation = class extends _opentelemetry_instrumentation.Instrum
 /**
 * Undici instrumentation for OpenTelemetry
 */
+function toRequestUrl(request) {
+	try {
+		return new URL(request.path, request.origin).toString();
+	} catch {
+		return;
+	}
+}
 /**
 * Creates an Undici instrumentation instance.
 * All requests are instrumented when the SDK is initialized.
@@ -1048,7 +1129,9 @@ function createUndiciInstrumentation() {
 	const globalConfig$1 = getGlobalConfig();
 	return new UndiciInstrumentation({
 		enabled: true,
-		ignoreRequestHook: () => false,
+		ignoreRequestHook: (request) => {
+			return shouldIgnoreOutboundInstrumentation(toRequestUrl(request));
+		},
 		maxRequestBodySize: globalConfig$1?.maxRequestBodySize,
 		maxResponseBodySize: globalConfig$1?.maxResponseBodySize
 	});