@pingops/core 0.1.3 → 0.2.1

package/dist/index.cjs

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