@noony-serverless/core 0.3.4 → 0.4.0

package/build/middlewares/openTelemetryMiddleware.js

@@ -0,0 +1,359 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openTelemetry = exports.OpenTelemetryMiddleware = void 0;
+const providers_1 = require("../core/telemetry/providers");
+const pubsub_trace_utils_1 = require("../utils/pubsub-trace.utils");
+/**
+ * OpenTelemetry Middleware
+ *
+ * Provides distributed tracing and metrics collection with:
+ * - Auto-detection of telemetry provider from environment
+ * - Graceful degradation when configuration is missing
+ * - Zero-configuration local development support
+ * - Type-safe generics to preserve middleware chain
+ *
+ * Provider Auto-Detection Priority:
+ * 1. Explicit provider via options.provider
+ * 2. New Relic (if NEW_RELIC_LICENSE_KEY set)
+ * 3. Datadog (if DD_API_KEY or DD_SERVICE set)
+ * 4. Standard OTEL (if OTEL_EXPORTER_OTLP_ENDPOINT set)
+ * 5. Console (if NODE_ENV=development and no OTEL endpoint)
+ * 6. Noop (if NODE_ENV=test or no configuration)
+ *
+ * @template TBody - Request body type
+ * @template TUser - Authenticated user type
+ *
+ * @example
+ * // Zero configuration (auto-detects provider)
+ * const handler = new Handler()
+ *   .use(new OpenTelemetryMiddleware())
+ *   .handle(async (context) => {
+ *     // Your business logic
+ *   });
+ *
+ * @example
+ * // With custom filtering
+ * const handler = new Handler()
+ *   .use(new OpenTelemetryMiddleware({
+ *     shouldTrace: (context) => context.req.path !== '/health'
+ *   }))
+ *   .handle(async (context) => {
+ *     // Your business logic
+ *   });
+ */
+class OpenTelemetryMiddleware {
+    provider;
+    enabled;
+    failSilently;
+    propagatePubSubTraces;
+    extractAttributes;
+    shouldTrace;
+    customErrorHandler;
+    initialized = false;
+    constructor(options = {}) {
+        this.enabled = options.enabled ?? process.env.NODE_ENV !== 'test';
+        this.failSilently = options.failSilently ?? true;
+        this.propagatePubSubTraces = options.propagatePubSubTraces ?? true;
+        this.extractAttributes =
+            options.extractAttributes || this.defaultExtractAttributes;
+        this.shouldTrace = options.shouldTrace || (() => true);
+        this.customErrorHandler = options.onError || this.defaultOnError;
+        // Use NoopProvider if disabled
+        if (!this.enabled) {
+            this.provider = new providers_1.NoopProvider();
+            return;
+        }
+        // Use provided provider or auto-detect
+        this.provider = options.provider || this.autoDetectProvider();
+    }
+    /**
+     * Auto-detect telemetry provider based on environment
+     */
+    autoDetectProvider() {
+        // Priority 1: New Relic (check for license key and package)
+        if (process.env.NEW_RELIC_LICENSE_KEY) {
+            try {
+                require.resolve('newrelic');
+                console.log('[Telemetry] Detected New Relic configuration');
+                // Note: NewRelicProvider would be imported here when implemented
+                // const { NewRelicProvider } = require('../core/telemetry/providers/newrelic-provider');
+                // return new NewRelicProvider();
+            }
+            catch {
+                console.warn('[Telemetry] NEW_RELIC_LICENSE_KEY set but newrelic package not installed');
+            }
+        }
+        // Priority 2: Datadog (check for API key or service name and package)
+        if (process.env.DD_API_KEY || process.env.DD_SERVICE) {
+            try {
+                require.resolve('dd-trace');
+                console.log('[Telemetry] Detected Datadog configuration');
+                // Note: DatadogProvider would be imported here when implemented
+                // const { DatadogProvider } = require('../core/telemetry/providers/datadog-provider');
+                // return new DatadogProvider();
+            }
+            catch {
+                console.warn('[Telemetry] Datadog config detected but dd-trace package not installed');
+            }
+        }
+        // Priority 3: Standard OTEL (check for OTLP endpoint)
+        if (process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
+            console.log('[Telemetry] Using standard OpenTelemetry provider');
+            return new providers_1.OpenTelemetryProvider();
+        }
+        // Priority 4: Console (development mode without OTEL endpoint)
+        if (process.env.NODE_ENV === 'development' &&
+            !process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
+            console.log('[Telemetry] Using console provider for local development');
+            return new providers_1.ConsoleProvider();
+        }
+        // Priority 5: Noop (no configuration found)
+        console.log('[Telemetry] No telemetry configuration detected, using Noop provider');
+        return new providers_1.NoopProvider();
+    }
+    /**
+     * Initialize provider with configuration
+     *
+     * This should be called once at application startup.
+     * If not called explicitly, it will be initialized on first request.
+     *
+     * @param config Telemetry configuration
+     */
+    async initialize(config) {
+        if (this.initialized)
+            return;
+        if (!this.enabled) {
+            this.initialized = true;
+            return;
+        }
+        try {
+            // Validate provider before initialization
+            const validation = await this.provider.validate();
+            if (!validation.valid) {
+                console.warn(`[Telemetry] Provider '${this.provider.name}' validation failed: ${validation.reason}`);
+                console.warn('[Telemetry] Falling back to Noop provider');
+                this.provider = new providers_1.NoopProvider();
+                this.initialized = true;
+                return;
+            }
+            // Initialize provider
+            await this.provider.initialize(config);
+            // Check if provider is ready
+            if (!this.provider.isReady()) {
+                console.warn(`[Telemetry] Provider '${this.provider.name}' initialization failed, falling back to Noop`);
+                this.provider = new providers_1.NoopProvider();
+            }
+            else {
+                console.log(`[Telemetry] Provider '${this.provider.name}' initialized successfully`);
+            }
+            this.initialized = true;
+        }
+        catch (error) {
+            console.error('[Telemetry] Failed to initialize provider:', error);
+            this.provider = new providers_1.NoopProvider();
+            this.initialized = true;
+        }
+    }
+    /**
+     * Before hook - Create span and store in context
+     *
+     * If propagatePubSubTraces is enabled and the request is a Pub/Sub message:
+     * 1. Extracts W3C Trace Context from message attributes
+     * 2. Creates a child span linked to the publisher's trace
+     * 3. Enables end-to-end distributed tracing across Pub/Sub
+     */
+    async before(context) {
+        if (!this.enabled)
+            return;
+        // Auto-initialize with minimal config if not initialized
+        if (!this.initialized) {
+            await this.initialize({
+                serviceName: process.env.SERVICE_NAME || 'noony-service',
+                serviceVersion: process.env.SERVICE_VERSION || '1.0.0',
+                environment: process.env.NODE_ENV || 'production',
+            });
+        }
+        // Check if should trace
+        if (!this.shouldTrace(context)) {
+            return;
+        }
+        try {
+            // Extract trace context from Pub/Sub message if enabled
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let parentContext = undefined;
+            if (this.propagatePubSubTraces && (0, pubsub_trace_utils_1.isPubSubMessage)(context.req.body)) {
+                const traceContext = (0, pubsub_trace_utils_1.extractTraceContext)(context.req.body);
+                if (traceContext.traceparent) {
+                    // Store trace context for span creation
+                    const carrier = (0, pubsub_trace_utils_1.createParentContext)(traceContext);
+                    // Try to extract parent context using OpenTelemetry API
+                    try {
+                        // eslint-disable-next-line @typescript-eslint/no-var-requires
+                        const otelApi = require('@opentelemetry/api');
+                        const { propagation, context: otelContext } = otelApi;
+                        // Extract parent context from carrier
+                        parentContext = propagation.extract(otelContext.active(), carrier);
+                        console.log('[Telemetry] Extracted Pub/Sub trace context:', {
+                            traceparent: traceContext.traceparent,
+                            tracestate: traceContext.tracestate,
+                        });
+                    }
+                    catch (err) {
+                        // OpenTelemetry API not available, continue without parent context
+                        console.warn('[Telemetry] Failed to extract Pub/Sub trace context:', err);
+                    }
+                }
+            }
+            // Create span (with parent context if available)
+            const span = this.provider.createSpan(context);
+            if (!span)
+                return;
+            // If we have a parent context from Pub/Sub, link the span
+            if (parentContext) {
+                span.setAttributes({
+                    'messaging.system': 'pubsub',
+                    'messaging.operation': 'process',
+                    'pubsub.message_id': 
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    context.req.body?.message?.messageId || 'unknown',
+                });
+            }
+            // Add custom attributes
+            const customAttributes = this.extractAttributes(context);
+            span.setAttributes(customAttributes);
+            // Store span and provider name in businessData
+            context.businessData.set('otel_span', span);
+            context.businessData.set('otel_provider', this.provider.name);
+        }
+        catch (error) {
+            if (!this.failSilently)
+                throw error;
+            console.error('[Telemetry] Error in before hook:', error);
+        }
+    }
+    /**
+     * After hook - End span with success status and add X-Trace-Id header
+     */
+    async after(context) {
+        if (!this.enabled)
+            return;
+        try {
+            const span = context.businessData.get('otel_span');
+            if (span) {
+                // Add response attributes
+                span.setAttributes({
+                    'http.status_code': context.res.statusCode || 200,
+                    'request.duration_ms': Date.now() - context.startTime,
+                });
+                // Add X-Trace-Id header with clean trace ID
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-var-requires
+                    const otelApi = require('@opentelemetry/api');
+                    const { context: otelContext, trace } = otelApi;
+                    // Get span from active context
+                    const activeContext = otelContext.active();
+                    const activeSpan = trace.getSpan(activeContext);
+                    if (activeSpan) {
+                        const spanContext = activeSpan.spanContext();
+                        if (spanContext.traceId) {
+                            // Add custom header with clean trace ID (32 hex chars)
+                            context.res.header('X-Trace-Id', spanContext.traceId);
+                        }
+                    }
+                }
+                catch (headerError) {
+                    // Non-critical error - don't fail the request
+                    console.warn('[Telemetry] Failed to add X-Trace-Id header:', headerError);
+                }
+                // Set success status (code 0 = OK in OTEL)
+                span.setStatus({ code: 0 });
+                // End span
+                span.end();
+            }
+        }
+        catch (error) {
+            if (!this.failSilently)
+                throw error;
+            console.error('[Telemetry] Error in after hook:', error);
+        }
+    }
+    /**
+     * Error hook - Record exception and end span
+     */
+    async onError(error, context) {
+        if (!this.enabled)
+            return;
+        try {
+            const span = context.businessData.get('otel_span');
+            if (span) {
+                // Record exception
+                span.recordException(error);
+                // Set error status (code 1 = ERROR in OTEL, code 2 = ERROR in some systems)
+                span.setStatus({
+                    code: 1,
+                    message: error.message,
+                });
+                // End span
+                span.end();
+            }
+            // Call custom error handler
+            this.customErrorHandler(error, context);
+        }
+        catch (err) {
+            if (!this.failSilently)
+                throw err;
+            console.error('[Telemetry] Error in onError hook:', err);
+        }
+    }
+    /**
+     * Default attribute extractor
+     */
+    defaultExtractAttributes(context) {
+        return {
+            'http.method': context.req.method,
+            'http.url': context.req.url || context.req.path,
+            'http.target': context.req.path || '/',
+            'request.id': context.requestId,
+            'http.user_agent': context.req.headers?.['user-agent'] || '',
+        };
+    }
+    /**
+     * Default error handler
+     */
+    defaultOnError(error, _context) {
+        console.error('[Telemetry] Request error:', {
+            name: error.name,
+            message: error.message,
+        });
+    }
+    /**
+     * Get current provider (useful for testing)
+     */
+    getProvider() {
+        return this.provider;
+    }
+    /**
+     * Shutdown telemetry provider
+     *
+     * Should be called during application shutdown to flush pending data.
+     */
+    async shutdown() {
+        if (this.provider) {
+            await this.provider.shutdown();
+        }
+    }
+}
+exports.OpenTelemetryMiddleware = OpenTelemetryMiddleware;
+/**
+ * Factory function for OpenTelemetry middleware
+ *
+ * @example
+ * const handler = new Handler()
+ *   .use(openTelemetry({ shouldTrace: ctx => ctx.req.path !== '/health' }))
+ *   .handle(async (context) => { });
+ */
+const openTelemetry = (options = {}) => {
+    return new OpenTelemetryMiddleware(options);
+};
+exports.openTelemetry = openTelemetry;
+//# sourceMappingURL=openTelemetryMiddleware.js.map

package/build/middlewares/rateLimitingMiddleware.js

@@ -618,6 +618,7 @@ exports.RateLimitPresets = {
         keyGenerator: (context) => {
             // Rate limit per IP + email combination for better security
             const ip = context.req.ip || 'unknown';
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const email = context.req.parsedBody?.email;
             return email ? `auth:${email}:${ip}` : `auth:${ip}`;
         },
@@ -670,28 +671,38 @@ exports.RateLimitPresets = {
             free: {
                 maxRequests: 100,
                 windowMs: 60000,
-                matcher: (context) => !context.user || context.user?.plan === 'free',
+                matcher: (context) => 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                !context.user || context.user?.plan === 'free',
             },
             premium: {
                 maxRequests: 1000,
                 windowMs: 60000,
-                matcher: (context) => context.user?.plan === 'premium',
+                matcher: (context) => 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                context.user?.plan === 'premium',
             },
             enterprise: {
                 maxRequests: 5000,
                 windowMs: 60000,
-                matcher: (context) => context.user?.plan === 'enterprise',
+                matcher: (context) => 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                context.user?.plan === 'enterprise',
             },
             admin: {
                 maxRequests: 10000,
                 windowMs: 60000,
-                matcher: (context) => context.user?.role === 'admin',
+                matcher: (context) => 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                context.user?.role === 'admin',
             },
         },
         keyGenerator: (context) => {
             // Use user ID for authenticated, IP for anonymous
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             return context.user?.id
-                ? `user:${context.user.id}`
+                ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    `user:${context.user.id}`
                 : `ip:${context.req.ip}`;
         },
     },

package/build/utils/container.utils.js

@@ -39,10 +39,13 @@ exports.getService = getService;
  * }
  * ```
  */
-function getService(context, serviceIdentifier) {
+function getService(context, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+serviceIdentifier) {
     if (!context.container) {
         throw new Error('Container not initialized. Did you forget to add DependencyInjectionMiddleware?');
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return context.container.get(serviceIdentifier);
 }
 //# sourceMappingURL=container.utils.js.map

package/build/utils/fastify-wrapper.d.ts

@@ -0,0 +1,74 @@
+import type { FastifyRequest, FastifyReply } from 'fastify';
+import { Handler } from '../core/handler';
+/**
+ * Create a Fastify route handler wrapper for a Noony handler
+ *
+ * Wraps a Noony handler into a Fastify route handler for use with Fastify server.
+ * This pattern enables running Noony handlers with Fastify's high-performance HTTP framework.
+ *
+ * @param noonyHandler - The Noony handler to wrap (contains middleware chain and controller)
+ * @param functionName - Name for error logging purposes
+ * @param initializeDependencies - Async function that initializes dependencies (database, services, etc.)
+ *                                  Uses singleton pattern to prevent re-initialization across requests
+ * @returns Fastify route handler: `(req: FastifyRequest, reply: FastifyReply) => Promise<void>`
+ *
+ * @remarks
+ * This wrapper ensures:
+ * - Dependencies are initialized before handler execution (singleton pattern for efficiency)
+ * - Noony handlers work seamlessly with Fastify routing
+ * - Errors are caught and returned as proper HTTP responses
+ * - Response is not sent twice (`reply.sent` check)
+ * - `RESPONSE_SENT` errors are ignored (response already sent by middleware)
+ * - Real errors return 500 with generic message for security
+ *
+ * @example
+ * Creating Fastify app with multiple routes:
+ * ```typescript
+ * import Fastify from 'fastify';
+ * import { createFastifyHandler } from '@noony-serverless/core';
+ * import { loginHandler, getConfigHandler } from './handlers';
+ *
+ * // Initialize dependencies once per app startup
+ * let initialized = false;
+ * async function initializeDependencies(): Promise<void> {
+ *   if (initialized) return;
+ *   const db = await databaseService.connect();
+ *   await initializeServices(db);
+ *   initialized = true;
+ * }
+ *
+ * const server = Fastify({ logger: true });
+ *
+ * // Helper shorthand
+ * const adapt = (handler, name) => createFastifyHandler(handler, name, initializeDependencies);
+ *
+ * // Auth routes
+ * server.post('/api/auth/login', adapt(loginHandler, 'login'));
+ *
+ * // Config routes
+ * server.get('/api/config', adapt(getConfigHandler, 'getConfig'));
+ *
+ * // Start server
+ * server.listen({ port: 3000 }, (err) => {
+ *   if (err) throw err;
+ *   console.log('Server running on port 3000');
+ * });
+ * ```
+ *
+ * @example
+ * Fastify routing with path parameters:
+ * ```typescript
+ * const server = Fastify();
+ *
+ * // Routes with path parameters work seamlessly
+ * server.get('/api/users/:userId', adapt(getUserHandler, 'getUser'));
+ * server.patch('/api/config/sections/:sectionId', adapt(updateSectionHandler, 'updateSection'));
+ *
+ * // Path parameters available in Noony handler via context.req.params
+ * ```
+ *
+ * @see {@link createHttpFunction} for Cloud Functions Framework integration (production deployment)
+ * @see {@link wrapNoonyHandler} for Express integration
+ */
+export declare function createFastifyHandler(noonyHandler: Handler<unknown>, functionName: string, initializeDependencies: () => Promise<void>): (req: FastifyRequest, reply: FastifyReply) => Promise<void>;
+//# sourceMappingURL=fastify-wrapper.d.ts.map

package/build/utils/fastify-wrapper.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFastifyHandler = createFastifyHandler;
+const logger_1 = require("../core/logger");
+/**
+ * Adapt Fastify Request to GenericRequest for Noony handlers
+ *
+ * @internal
+ */
+function adaptFastifyRequest(req) {
+    return {
+        method: req.method,
+        url: req.url,
+        path: req.routeOptions?.url || req.url,
+        headers: req.headers,
+        query: (req.query || {}),
+        params: (req.params || {}),
+        body: req.body,
+        // Fastify already parses the body, so set parsedBody for BodyValidationMiddleware
+        parsedBody: req.body,
+        ip: req.ip,
+        userAgent: req.headers['user-agent'],
+    };
+}
+/**
+ * Adapt Fastify Reply to GenericResponse for Noony handlers
+ *
+ * @internal
+ */
+function adaptFastifyResponse(reply) {
+    let statusCode = 200;
+    let headersSent = false;
+    const response = {
+        status(code) {
+            statusCode = code;
+            reply.code(code);
+            return response;
+        },
+        json(data) {
+            headersSent = true;
+            reply.send(data);
+            return response;
+        },
+        send(data) {
+            headersSent = true;
+            reply.send(data);
+            return response;
+        },
+        header(name, value) {
+            reply.header(name, value);
+            return response;
+        },
+        headers(headers) {
+            Object.entries(headers).forEach(([key, value]) => {
+                reply.header(key, value);
+            });
+            return response;
+        },
+        end() {
+            headersSent = true;
+            reply.send();
+        },
+        get statusCode() {
+            return statusCode;
+        },
+        get headersSent() {
+            return headersSent || reply.sent;
+        },
+    };
+    return response;
+}
+/**
+ * Create a Fastify route handler wrapper for a Noony handler
+ *
+ * Wraps a Noony handler into a Fastify route handler for use with Fastify server.
+ * This pattern enables running Noony handlers with Fastify's high-performance HTTP framework.
+ *
+ * @param noonyHandler - The Noony handler to wrap (contains middleware chain and controller)
+ * @param functionName - Name for error logging purposes
+ * @param initializeDependencies - Async function that initializes dependencies (database, services, etc.)
+ *                                  Uses singleton pattern to prevent re-initialization across requests
+ * @returns Fastify route handler: `(req: FastifyRequest, reply: FastifyReply) => Promise<void>`
+ *
+ * @remarks
+ * This wrapper ensures:
+ * - Dependencies are initialized before handler execution (singleton pattern for efficiency)
+ * - Noony handlers work seamlessly with Fastify routing
+ * - Errors are caught and returned as proper HTTP responses
+ * - Response is not sent twice (`reply.sent` check)
+ * - `RESPONSE_SENT` errors are ignored (response already sent by middleware)
+ * - Real errors return 500 with generic message for security
+ *
+ * @example
+ * Creating Fastify app with multiple routes:
+ * ```typescript
+ * import Fastify from 'fastify';
+ * import { createFastifyHandler } from '@noony-serverless/core';
+ * import { loginHandler, getConfigHandler } from './handlers';
+ *
+ * // Initialize dependencies once per app startup
+ * let initialized = false;
+ * async function initializeDependencies(): Promise<void> {
+ *   if (initialized) return;
+ *   const db = await databaseService.connect();
+ *   await initializeServices(db);
+ *   initialized = true;
+ * }
+ *
+ * const server = Fastify({ logger: true });
+ *
+ * // Helper shorthand
+ * const adapt = (handler, name) => createFastifyHandler(handler, name, initializeDependencies);
+ *
+ * // Auth routes
+ * server.post('/api/auth/login', adapt(loginHandler, 'login'));
+ *
+ * // Config routes
+ * server.get('/api/config', adapt(getConfigHandler, 'getConfig'));
+ *
+ * // Start server
+ * server.listen({ port: 3000 }, (err) => {
+ *   if (err) throw err;
+ *   console.log('Server running on port 3000');
+ * });
+ * ```
+ *
+ * @example
+ * Fastify routing with path parameters:
+ * ```typescript
+ * const server = Fastify();
+ *
+ * // Routes with path parameters work seamlessly
+ * server.get('/api/users/:userId', adapt(getUserHandler, 'getUser'));
+ * server.patch('/api/config/sections/:sectionId', adapt(updateSectionHandler, 'updateSection'));
+ *
+ * // Path parameters available in Noony handler via context.req.params
+ * ```
+ *
+ * @see {@link createHttpFunction} for Cloud Functions Framework integration (production deployment)
+ * @see {@link wrapNoonyHandler} for Express integration
+ */
+function createFastifyHandler(noonyHandler, functionName, initializeDependencies) {
+    return async (req, reply) => {
+        try {
+            // Ensure dependencies are initialized
+            await initializeDependencies();
+            // Adapt Fastify req/reply to GenericRequest/GenericResponse
+            const genericReq = adaptFastifyRequest(req);
+            const genericRes = adaptFastifyResponse(reply);
+            // Execute Noony handler with adapted request/response
+            await noonyHandler.executeGeneric(genericReq, genericRes);
+        }
+        catch (error) {
+            // Ignore RESPONSE_SENT markers (response already sent by middleware)
+            if (error instanceof Error && error.message === 'RESPONSE_SENT') {
+                return;
+            }
+            logger_1.logger.error(`${functionName} handler error`, {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            // Graceful error handling - only send if response not already sent
+            if (!reply.sent) {
+                reply.code(500).send({
+                    success: false,
+                    error: {
+                        code: 'INTERNAL_SERVER_ERROR',
+                        message: 'An unexpected error occurred',
+                    },
+                });
+            }
+        }
+    };
+}
+//# sourceMappingURL=fastify-wrapper.js.map

package/build/utils/index.d.ts

@@ -3,4 +3,8 @@
  */
 export { getService } from './container.utils';
 export { asString, asStringArray, asNumber, asBoolean, } from './query-param.utils';
+export { isPubSubMessage, extractTraceContext, injectTraceContext, createParentContext, type PubSubMessage, type TraceContext, } from './pubsub-trace.utils';
+export { createOTELMixin, getOTELContext, getOTELContextFromSpan, getOTELContextFromContext, formatTraceIdForCloudLogging, createCloudLoggingEntry, isOTELActive, isOTELInstalled, type OTELLogContext, } from './otel.helper';
+export { createHttpFunction, wrapNoonyHandler } from './wrapper-utils';
+export { createFastifyHandler } from './fastify-wrapper';
 //# sourceMappingURL=index.d.ts.map