@noony-serverless/core 0.3.4 → 0.4.0

package/build/utils/index.js

@@ -3,7 +3,7 @@
  * Utility functions for Noony Core
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.asBoolean = exports.asNumber = exports.asStringArray = exports.asString = exports.getService = void 0;
+exports.createFastifyHandler = exports.wrapNoonyHandler = exports.createHttpFunction = exports.isOTELInstalled = exports.isOTELActive = exports.createCloudLoggingEntry = exports.formatTraceIdForCloudLogging = exports.getOTELContextFromContext = exports.getOTELContextFromSpan = exports.getOTELContext = exports.createOTELMixin = exports.createParentContext = exports.injectTraceContext = exports.extractTraceContext = exports.isPubSubMessage = exports.asBoolean = exports.asNumber = exports.asStringArray = exports.asString = exports.getService = void 0;
 // Container utilities
 var container_utils_1 = require("./container.utils");
 Object.defineProperty(exports, "getService", { enumerable: true, get: function () { return container_utils_1.getService; } });
@@ -13,4 +13,26 @@ Object.defineProperty(exports, "asString", { enumerable: true, get: function ()
 Object.defineProperty(exports, "asStringArray", { enumerable: true, get: function () { return query_param_utils_1.asStringArray; } });
 Object.defineProperty(exports, "asNumber", { enumerable: true, get: function () { return query_param_utils_1.asNumber; } });
 Object.defineProperty(exports, "asBoolean", { enumerable: true, get: function () { return query_param_utils_1.asBoolean; } });
+// Pub/Sub trace propagation utilities
+var pubsub_trace_utils_1 = require("./pubsub-trace.utils");
+Object.defineProperty(exports, "isPubSubMessage", { enumerable: true, get: function () { return pubsub_trace_utils_1.isPubSubMessage; } });
+Object.defineProperty(exports, "extractTraceContext", { enumerable: true, get: function () { return pubsub_trace_utils_1.extractTraceContext; } });
+Object.defineProperty(exports, "injectTraceContext", { enumerable: true, get: function () { return pubsub_trace_utils_1.injectTraceContext; } });
+Object.defineProperty(exports, "createParentContext", { enumerable: true, get: function () { return pubsub_trace_utils_1.createParentContext; } });
+// OpenTelemetry logger integration utilities
+var otel_helper_1 = require("./otel.helper");
+Object.defineProperty(exports, "createOTELMixin", { enumerable: true, get: function () { return otel_helper_1.createOTELMixin; } });
+Object.defineProperty(exports, "getOTELContext", { enumerable: true, get: function () { return otel_helper_1.getOTELContext; } });
+Object.defineProperty(exports, "getOTELContextFromSpan", { enumerable: true, get: function () { return otel_helper_1.getOTELContextFromSpan; } });
+Object.defineProperty(exports, "getOTELContextFromContext", { enumerable: true, get: function () { return otel_helper_1.getOTELContextFromContext; } });
+Object.defineProperty(exports, "formatTraceIdForCloudLogging", { enumerable: true, get: function () { return otel_helper_1.formatTraceIdForCloudLogging; } });
+Object.defineProperty(exports, "createCloudLoggingEntry", { enumerable: true, get: function () { return otel_helper_1.createCloudLoggingEntry; } });
+Object.defineProperty(exports, "isOTELActive", { enumerable: true, get: function () { return otel_helper_1.isOTELActive; } });
+Object.defineProperty(exports, "isOTELInstalled", { enumerable: true, get: function () { return otel_helper_1.isOTELInstalled; } });
+// Wrapper utilities for GCP Functions, Express, and Fastify
+var wrapper_utils_1 = require("./wrapper-utils");
+Object.defineProperty(exports, "createHttpFunction", { enumerable: true, get: function () { return wrapper_utils_1.createHttpFunction; } });
+Object.defineProperty(exports, "wrapNoonyHandler", { enumerable: true, get: function () { return wrapper_utils_1.wrapNoonyHandler; } });
+var fastify_wrapper_1 = require("./fastify-wrapper");
+Object.defineProperty(exports, "createFastifyHandler", { enumerable: true, get: function () { return fastify_wrapper_1.createFastifyHandler; } });
 //# sourceMappingURL=index.js.map

package/build/utils/otel.helper.d.ts

@@ -0,0 +1,122 @@
+/**
+ * OpenTelemetry Helper Utilities
+ *
+ * Provides helper functions for integrating OpenTelemetry with logging systems.
+ * These utilities enable automatic trace/span ID injection into log entries for
+ * correlation with distributed traces in Cloud Logging and other observability platforms.
+ *
+ * @module utils/otel.helper
+ */
+import type { Context as OtelContext, Span } from '@opentelemetry/api';
+/**
+ * OTEL context object for logger integration
+ */
+export interface OTELLogContext {
+    traceId?: string;
+    spanId?: string;
+    traceFlags?: number;
+}
+/**
+ * Create Pino mixin for automatic trace/span ID injection
+ *
+ * This function creates a Pino mixin that automatically adds OpenTelemetry
+ * trace and span IDs to every log entry. This enables log-trace correlation
+ * in Cloud Logging and other observability platforms.
+ *
+ * Usage with Pino:
+ * ```typescript
+ * import pino from 'pino';
+ * import { createOTELMixin } from '@noony-serverless/core';
+ *
+ * const logger = pino({
+ *   mixin: createOTELMixin,
+ *   // ... other config
+ * });
+ *
+ * logger.info('User created'); // Automatically includes traceId, spanId, traceFlags
+ * ```
+ *
+ * Log output example:
+ * ```json
+ * {
+ *   "level": 30,
+ *   "time": 1640000000000,
+ *   "msg": "User created",
+ *   "traceId": "13ea7e3c2d3b4547baaa399062df1f2d",
+ *   "spanId": "1234567890123456",
+ *   "traceFlags": 1
+ * }
+ * ```
+ *
+ * @returns Mixin object with trace context or empty object if no active span
+ */
+export declare const createOTELMixin: () => OTELLogContext;
+/**
+ * Extract OTEL context from active span
+ *
+ * Similar to createOTELMixin but returns undefined if no span is active,
+ * making it easier to conditionally add trace context.
+ *
+ * @returns OTEL context or undefined if no active span
+ */
+export declare const getOTELContext: () => OTELLogContext | undefined;
+/**
+ * Extract OTEL context from a specific span
+ *
+ * Useful when you have a reference to a span and want to extract its context
+ * for logging or propagation purposes.
+ *
+ * @param span - The OpenTelemetry span to extract context from
+ * @returns OTEL context from the span
+ */
+export declare const getOTELContextFromSpan: (span: Span) => OTELLogContext;
+/**
+ * Extract OTEL context from an OTEL Context object
+ *
+ * Useful when working with OTEL Context propagation (e.g., in Pub/Sub messages)
+ * and you need to extract the span context for logging.
+ *
+ * @param context - The OpenTelemetry context to extract from
+ * @returns OTEL context from the context or undefined if no span
+ */
+export declare const getOTELContextFromContext: (context: OtelContext) => OTELLogContext | undefined;
+/**
+ * Format trace ID for Cloud Logging
+ *
+ * Cloud Logging expects trace IDs in a specific format:
+ * projects/[PROJECT_ID]/traces/[TRACE_ID]
+ *
+ * This function formats a raw trace ID into the Cloud Logging format.
+ *
+ * @param traceId - Raw trace ID (32-character hex string)
+ * @param projectId - GCP project ID (optional, defaults to GOOGLE_CLOUD_PROJECT env var)
+ * @returns Formatted trace ID for Cloud Logging or undefined if inputs invalid
+ */
+export declare const formatTraceIdForCloudLogging: (traceId?: string, projectId?: string) => string | undefined;
+/**
+ * Create Cloud Logging compatible log entry
+ *
+ * Combines OTEL context with log metadata to create a Cloud Logging compatible
+ * log entry with trace correlation.
+ *
+ * @param message - Log message
+ * @param metadata - Additional log metadata
+ * @param projectId - GCP project ID (optional)
+ * @returns Cloud Logging compatible log entry
+ */
+export declare const createCloudLoggingEntry: (message: string, metadata?: Record<string, any>, projectId?: string) => Record<string, any>;
+/**
+ * Check if OpenTelemetry is available and active
+ *
+ * Useful for conditional OTEL feature usage in libraries and applications.
+ *
+ * @returns true if OTEL is available and there's an active span
+ */
+export declare const isOTELActive: () => boolean;
+/**
+ * Check if OpenTelemetry SDK is installed
+ *
+ * @returns true if @opentelemetry/api is installed
+ */
+export declare const isOTELInstalled: () => boolean;
+//# sourceMappingURL=otel.helper.d.ts.map

package/build/utils/otel.helper.js

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * OpenTelemetry Helper Utilities
+ *
+ * Provides helper functions for integrating OpenTelemetry with logging systems.
+ * These utilities enable automatic trace/span ID injection into log entries for
+ * correlation with distributed traces in Cloud Logging and other observability platforms.
+ *
+ * @module utils/otel.helper
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOTELInstalled = exports.isOTELActive = exports.createCloudLoggingEntry = exports.formatTraceIdForCloudLogging = exports.getOTELContextFromContext = exports.getOTELContextFromSpan = exports.getOTELContext = exports.createOTELMixin = void 0;
+// Conditional OpenTelemetry import (optional dependency)
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let trace;
+try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const otelApi = require('@opentelemetry/api');
+    trace = otelApi.trace;
+}
+catch {
+    // OpenTelemetry not installed - helpers will return empty objects
+    trace = null;
+}
+/**
+ * Create Pino mixin for automatic trace/span ID injection
+ *
+ * This function creates a Pino mixin that automatically adds OpenTelemetry
+ * trace and span IDs to every log entry. This enables log-trace correlation
+ * in Cloud Logging and other observability platforms.
+ *
+ * Usage with Pino:
+ * ```typescript
+ * import pino from 'pino';
+ * import { createOTELMixin } from '@noony-serverless/core';
+ *
+ * const logger = pino({
+ *   mixin: createOTELMixin,
+ *   // ... other config
+ * });
+ *
+ * logger.info('User created'); // Automatically includes traceId, spanId, traceFlags
+ * ```
+ *
+ * Log output example:
+ * ```json
+ * {
+ *   "level": 30,
+ *   "time": 1640000000000,
+ *   "msg": "User created",
+ *   "traceId": "13ea7e3c2d3b4547baaa399062df1f2d",
+ *   "spanId": "1234567890123456",
+ *   "traceFlags": 1
+ * }
+ * ```
+ *
+ * @returns Mixin object with trace context or empty object if no active span
+ */
+const createOTELMixin = () => {
+    if (!trace) {
+        return {};
+    }
+    try {
+        const span = trace.getActiveSpan();
+        if (!span) {
+            return {};
+        }
+        const spanContext = span.spanContext();
+        return {
+            traceId: spanContext.traceId,
+            spanId: spanContext.spanId,
+            traceFlags: spanContext.traceFlags,
+        };
+    }
+    catch (error) {
+        // Gracefully handle any errors in trace extraction
+        return {};
+    }
+};
+exports.createOTELMixin = createOTELMixin;
+/**
+ * Extract OTEL context from active span
+ *
+ * Similar to createOTELMixin but returns undefined if no span is active,
+ * making it easier to conditionally add trace context.
+ *
+ * @returns OTEL context or undefined if no active span
+ */
+const getOTELContext = () => {
+    if (!trace) {
+        return undefined;
+    }
+    try {
+        const span = trace.getActiveSpan();
+        if (!span) {
+            return undefined;
+        }
+        const spanContext = span.spanContext();
+        return {
+            traceId: spanContext.traceId,
+            spanId: spanContext.spanId,
+            traceFlags: spanContext.traceFlags,
+        };
+    }
+    catch (error) {
+        return undefined;
+    }
+};
+exports.getOTELContext = getOTELContext;
+/**
+ * Extract OTEL context from a specific span
+ *
+ * Useful when you have a reference to a span and want to extract its context
+ * for logging or propagation purposes.
+ *
+ * @param span - The OpenTelemetry span to extract context from
+ * @returns OTEL context from the span
+ */
+const getOTELContextFromSpan = (span) => {
+    try {
+        const spanContext = span.spanContext();
+        return {
+            traceId: spanContext.traceId,
+            spanId: spanContext.spanId,
+            traceFlags: spanContext.traceFlags,
+        };
+    }
+    catch (error) {
+        return {};
+    }
+};
+exports.getOTELContextFromSpan = getOTELContextFromSpan;
+/**
+ * Extract OTEL context from an OTEL Context object
+ *
+ * Useful when working with OTEL Context propagation (e.g., in Pub/Sub messages)
+ * and you need to extract the span context for logging.
+ *
+ * @param context - The OpenTelemetry context to extract from
+ * @returns OTEL context from the context or undefined if no span
+ */
+const getOTELContextFromContext = (context) => {
+    if (!trace) {
+        return undefined;
+    }
+    try {
+        const span = trace.getSpan(context);
+        if (!span) {
+            return undefined;
+        }
+        const spanContext = span.spanContext();
+        return {
+            traceId: spanContext.traceId,
+            spanId: spanContext.spanId,
+            traceFlags: spanContext.traceFlags,
+        };
+    }
+    catch (error) {
+        return undefined;
+    }
+};
+exports.getOTELContextFromContext = getOTELContextFromContext;
+/**
+ * Format trace ID for Cloud Logging
+ *
+ * Cloud Logging expects trace IDs in a specific format:
+ * projects/[PROJECT_ID]/traces/[TRACE_ID]
+ *
+ * This function formats a raw trace ID into the Cloud Logging format.
+ *
+ * @param traceId - Raw trace ID (32-character hex string)
+ * @param projectId - GCP project ID (optional, defaults to GOOGLE_CLOUD_PROJECT env var)
+ * @returns Formatted trace ID for Cloud Logging or undefined if inputs invalid
+ */
+const formatTraceIdForCloudLogging = (traceId, projectId) => {
+    if (!traceId) {
+        return undefined;
+    }
+    const project = projectId || process.env.GOOGLE_CLOUD_PROJECT || process.env.GCP_PROJECT;
+    if (!project) {
+        return undefined;
+    }
+    return `projects/${project}/traces/${traceId}`;
+};
+exports.formatTraceIdForCloudLogging = formatTraceIdForCloudLogging;
+/**
+ * Create Cloud Logging compatible log entry
+ *
+ * Combines OTEL context with log metadata to create a Cloud Logging compatible
+ * log entry with trace correlation.
+ *
+ * @param message - Log message
+ * @param metadata - Additional log metadata
+ * @param projectId - GCP project ID (optional)
+ * @returns Cloud Logging compatible log entry
+ */
+const createCloudLoggingEntry = (message, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+metadata = {}, projectId
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) => {
+    const otelContext = (0, exports.getOTELContext)();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const entry = {
+        message,
+        ...metadata,
+    };
+    if (otelContext?.traceId) {
+        entry.traceId = otelContext.traceId;
+        entry.spanId = otelContext.spanId;
+        // Add Cloud Logging trace reference
+        const formattedTrace = (0, exports.formatTraceIdForCloudLogging)(otelContext.traceId, projectId);
+        if (formattedTrace) {
+            entry['logging.googleapis.com/trace'] = formattedTrace;
+        }
+        // Add span ID for Cloud Logging correlation
+        if (otelContext.spanId) {
+            entry['logging.googleapis.com/spanId'] = otelContext.spanId;
+        }
+        // Add trace sampled flag
+        if (otelContext.traceFlags !== undefined) {
+            entry['logging.googleapis.com/trace_sampled'] =
+                (otelContext.traceFlags & 1) === 1;
+        }
+    }
+    return entry;
+};
+exports.createCloudLoggingEntry = createCloudLoggingEntry;
+/**
+ * Check if OpenTelemetry is available and active
+ *
+ * Useful for conditional OTEL feature usage in libraries and applications.
+ *
+ * @returns true if OTEL is available and there's an active span
+ */
+const isOTELActive = () => {
+    if (!trace) {
+        return false;
+    }
+    try {
+        const span = trace.getActiveSpan();
+        return !!span;
+    }
+    catch {
+        return false;
+    }
+};
+exports.isOTELActive = isOTELActive;
+/**
+ * Check if OpenTelemetry SDK is installed
+ *
+ * @returns true if @opentelemetry/api is installed
+ */
+const isOTELInstalled = () => {
+    return !!trace;
+};
+exports.isOTELInstalled = isOTELInstalled;
+//# sourceMappingURL=otel.helper.js.map

package/build/utils/pubsub-trace.utils.d.ts

@@ -0,0 +1,102 @@
+import { Context } from '../core';
+/**
+ * Google Cloud Pub/Sub message structure
+ */
+export interface PubSubMessage {
+    message: {
+        data: string;
+        publishTime?: string;
+        messageId?: string;
+        attributes?: Record<string, string>;
+    };
+}
+/**
+ * W3C Trace Context extracted from Pub/Sub message attributes
+ */
+export interface TraceContext {
+    traceparent?: string;
+    tracestate?: string;
+}
+/**
+ * Type guard to check if request body is a Pub/Sub message
+ *
+ * @param body - Request body to check
+ * @returns True if body is a Pub/Sub message
+ *
+ * @example
+ * if (isPubSubMessage(context.req.body)) {
+ *   const traceContext = extractTraceContext(context.req.body);
+ * }
+ */
+export declare function isPubSubMessage(body: unknown): body is PubSubMessage;
+/**
+ * Extract W3C Trace Context from Pub/Sub message attributes
+ *
+ * Extracts the following headers from message.attributes:
+ * - `traceparent`: W3C Trace Context propagation header (required)
+ * - `tracestate`: Vendor-specific trace state (optional)
+ *
+ * @param message - Pub/Sub message
+ * @returns Trace context object with traceparent and tracestate
+ *
+ * @example
+ * const traceContext = extractTraceContext(pubsubMessage);
+ * if (traceContext.traceparent) {
+ *   console.log('Parent trace ID:', traceContext.traceparent);
+ * }
+ */
+export declare function extractTraceContext(message: PubSubMessage): TraceContext;
+/**
+ * Inject W3C Trace Context into Pub/Sub message attributes
+ *
+ * Adds trace context from the current OpenTelemetry span to message attributes.
+ * This enables distributed tracing across Pub/Sub publishers and subscribers.
+ *
+ * The trace context is extracted using OpenTelemetry's propagation API and
+ * injected into the message attributes as:
+ * - `traceparent`: W3C Trace Context version-traceid-spanid-flags
+ * - `tracestate`: Vendor-specific trace state (if present)
+ *
+ * @param message - Pub/Sub message to inject trace context into
+ * @param context - Noony request context (optional, used to get active span)
+ * @returns Message with trace context injected into attributes
+ *
+ * @example
+ * // Publishing a message with trace context
+ * import { injectTraceContext } from '@noony-serverless/core';
+ *
+ * const message = {
+ *   data: Buffer.from(JSON.stringify({ userId: '123' })).toString('base64'),
+ *   attributes: {
+ *     type: 'user.created'
+ *   }
+ * };
+ *
+ * const tracedMessage = injectTraceContext(message, context);
+ * await pubsub.topic('users').publish(tracedMessage);
+ *
+ * @example
+ * // Publishing without context (uses active span from context)
+ * const tracedMessage = injectTraceContext(message);
+ * await pubsub.topic('users').publish(tracedMessage);
+ */
+export declare function injectTraceContext(message: {
+    data: string;
+    attributes?: Record<string, string>;
+}, context?: Context<unknown, unknown>): {
+    data: string;
+    attributes: Record<string, string>;
+};
+/**
+ * Extract trace context and create parent context for OpenTelemetry
+ *
+ * This is a lower-level utility used internally by OpenTelemetryMiddleware.
+ * Most users should use the middleware's automatic trace propagation instead.
+ *
+ * @param traceContext - Extracted W3C trace context
+ * @returns OpenTelemetry context with extracted trace context
+ *
+ * @internal
+ */
+export declare function createParentContext(traceContext: TraceContext): Record<string, string>;
+//# sourceMappingURL=pubsub-trace.utils.d.ts.map

package/build/utils/pubsub-trace.utils.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPubSubMessage = isPubSubMessage;
+exports.extractTraceContext = extractTraceContext;
+exports.injectTraceContext = injectTraceContext;
+exports.createParentContext = createParentContext;
+/**
+ * Type guard to check if request body is a Pub/Sub message
+ *
+ * @param body - Request body to check
+ * @returns True if body is a Pub/Sub message
+ *
+ * @example
+ * if (isPubSubMessage(context.req.body)) {
+ *   const traceContext = extractTraceContext(context.req.body);
+ * }
+ */
+function isPubSubMessage(body) {
+    return (!!body &&
+        typeof body === 'object' &&
+        'message' in body &&
+        typeof body.message === 'object' &&
+        'data' in body.message);
+}
+/**
+ * Extract W3C Trace Context from Pub/Sub message attributes
+ *
+ * Extracts the following headers from message.attributes:
+ * - `traceparent`: W3C Trace Context propagation header (required)
+ * - `tracestate`: Vendor-specific trace state (optional)
+ *
+ * @param message - Pub/Sub message
+ * @returns Trace context object with traceparent and tracestate
+ *
+ * @example
+ * const traceContext = extractTraceContext(pubsubMessage);
+ * if (traceContext.traceparent) {
+ *   console.log('Parent trace ID:', traceContext.traceparent);
+ * }
+ */
+function extractTraceContext(message) {
+    const attributes = message.message.attributes || {};
+    return {
+        traceparent: attributes.traceparent,
+        tracestate: attributes.tracestate,
+    };
+}
+/**
+ * Inject W3C Trace Context into Pub/Sub message attributes
+ *
+ * Adds trace context from the current OpenTelemetry span to message attributes.
+ * This enables distributed tracing across Pub/Sub publishers and subscribers.
+ *
+ * The trace context is extracted using OpenTelemetry's propagation API and
+ * injected into the message attributes as:
+ * - `traceparent`: W3C Trace Context version-traceid-spanid-flags
+ * - `tracestate`: Vendor-specific trace state (if present)
+ *
+ * @param message - Pub/Sub message to inject trace context into
+ * @param context - Noony request context (optional, used to get active span)
+ * @returns Message with trace context injected into attributes
+ *
+ * @example
+ * // Publishing a message with trace context
+ * import { injectTraceContext } from '@noony-serverless/core';
+ *
+ * const message = {
+ *   data: Buffer.from(JSON.stringify({ userId: '123' })).toString('base64'),
+ *   attributes: {
+ *     type: 'user.created'
+ *   }
+ * };
+ *
+ * const tracedMessage = injectTraceContext(message, context);
+ * await pubsub.topic('users').publish(tracedMessage);
+ *
+ * @example
+ * // Publishing without context (uses active span from context)
+ * const tracedMessage = injectTraceContext(message);
+ * await pubsub.topic('users').publish(tracedMessage);
+ */
+function injectTraceContext(message, context) {
+    // Initialize attributes if not present
+    const attributes = message.attributes || {};
+    try {
+        // Try to use OpenTelemetry API if available
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const otelApi = require('@opentelemetry/api');
+        const { trace, propagation, context: otelContext } = otelApi;
+        // Get current context (either from provided context or active context)
+        let activeContext = otelContext.active();
+        // If Noony context provided, try to get span from businessData
+        if (context) {
+            const span = context.businessData.get('otel_span');
+            if (span && typeof span === 'object' && 'spanContext' in span) {
+                // Create context with span
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                activeContext = trace.setSpan(activeContext, span);
+            }
+        }
+        // Get active span if no span found in businessData
+        const activeSpan = trace.getSpan(activeContext);
+        if (!activeSpan) {
+            // No active span, return message without trace context
+            return {
+                data: message.data,
+                attributes,
+            };
+        }
+        // Inject trace context into a carrier object
+        const carrier = {};
+        propagation.inject(activeContext, carrier);
+        // Merge trace context into message attributes
+        return {
+            data: message.data,
+            attributes: {
+                ...attributes,
+                ...carrier, // This adds traceparent and tracestate
+            },
+        };
+    }
+    catch (error) {
+        // OpenTelemetry not available or error during injection
+        // Return message without trace context (fail gracefully)
+        console.warn('[Telemetry] Failed to inject trace context:', error);
+        return {
+            data: message.data,
+            attributes,
+        };
+    }
+}
+/**
+ * Extract trace context and create parent context for OpenTelemetry
+ *
+ * This is a lower-level utility used internally by OpenTelemetryMiddleware.
+ * Most users should use the middleware's automatic trace propagation instead.
+ *
+ * @param traceContext - Extracted W3C trace context
+ * @returns OpenTelemetry context with extracted trace context
+ *
+ * @internal
+ */
+function createParentContext(traceContext) {
+    if (!traceContext.traceparent) {
+        return {};
+    }
+    const carrier = {
+        traceparent: traceContext.traceparent,
+    };
+    if (traceContext.tracestate) {
+        carrier.tracestate = traceContext.tracestate;
+    }
+    return carrier;
+}
+//# sourceMappingURL=pubsub-trace.utils.js.map