@juspay/neurolink 9.41.0 → 9.42.1

package/dist/lib/services/server/ai/observability/instrumentation.d.ts

@@ -8,7 +8,8 @@
  */
 import { LangfuseSpanProcessor } from "@langfuse/otel";
 import { trace } from "@opentelemetry/api";
-import type { SpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { LoggerProvider } from "@opentelemetry/sdk-logs";
+import { type SpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import type { LangfuseConfig } from "../../../../types/observability.js";
 /**
@@ -104,6 +105,11 @@ export declare function getLangfuseSpanProcessor(): LangfuseSpanProcessor | null
  * Get the tracer provider
  */
 export declare function getTracerProvider(): NodeTracerProvider | null;
+/**
+ * Get the logger provider for emitting OTLP log records.
+ * Returns null if OTLP is not configured or LoggerProvider was not created.
+ */
+export declare function getLoggerProvider(): LoggerProvider | null;
 /**
  * Check if OpenTelemetry is initialized
  */

package/dist/lib/services/server/ai/observability/instrumentation.js

@@ -7,15 +7,90 @@
  * Flow: Vercel AI SDK → OpenTelemetry Spans → LangfuseSpanProcessor → Langfuse Platform
  */
 import { LangfuseSpanProcessor } from "@langfuse/otel";
-import { trace } from "@opentelemetry/api";
+import { metrics, trace } from "@opentelemetry/api";
+import { W3CTraceContextPropagator } from "@opentelemetry/core";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { resourceFromAttributes } from "@opentelemetry/resources";
+import { MeterProvider, PeriodicExportingMetricReader, } from "@opentelemetry/sdk-metrics";
+import { BatchLogRecordProcessor, LoggerProvider, } from "@opentelemetry/sdk-logs";
+import { BatchSpanProcessor, } from "@opentelemetry/sdk-trace-base";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from "@opentelemetry/semantic-conventions";
 import { AsyncLocalStorage } from "async_hooks";
 import { logger } from "../../../../utils/logger.js";
 const LOG_PREFIX = "[OpenTelemetry]";
+function createOtelResource(config, serviceName) {
+    return resourceFromAttributes({
+        [ATTR_SERVICE_NAME]: serviceName,
+        [ATTR_SERVICE_VERSION]: config.release || "v1.0.0",
+        "deployment.environment": config.environment || "dev",
+    });
+}
+function initializeOtlpMetricsAndLogs(resource, otlpEndpoint, serviceName) {
+    if (!otlpEndpoint) {
+        return;
+    }
+    try {
+        const metricExporter = new OTLPMetricExporter({
+            url: `${otlpEndpoint}/v1/metrics`,
+        });
+        const metricReader = new PeriodicExportingMetricReader({
+            exporter: metricExporter,
+            exportIntervalMillis: 15000,
+            exportTimeoutMillis: 10000,
+        });
+        meterProvider = new MeterProvider({
+            resource,
+            readers: [metricReader],
+        });
+        metrics.setGlobalMeterProvider(meterProvider);
+        logger.info(`${LOG_PREFIX} OTLP metric exporter added — MeterProvider registered globally`, {
+            endpoint: `${otlpEndpoint}/v1/metrics`,
+            exportIntervalMs: 15000,
+            serviceName,
+            meterProviderType: meterProvider.constructor.name,
+        });
+    }
+    catch (metricsError) {
+        logger.warn(`${LOG_PREFIX} Failed to create OTLP metric exporter (non-fatal)`, {
+            error: metricsError instanceof Error
+                ? metricsError.message
+                : String(metricsError),
+            endpoint: otlpEndpoint,
+        });
+    }
+    try {
+        const logExporter = new OTLPLogExporter({
+            url: `${otlpEndpoint}/v1/logs`,
+        });
+        const logProcessor = new BatchLogRecordProcessor(logExporter, {
+            maxQueueSize: 2048,
+            maxExportBatchSize: 512,
+            scheduledDelayMillis: 2000,
+            exportTimeoutMillis: 30000,
+        });
+        loggerProvider = new LoggerProvider({
+            resource,
+            processors: [logProcessor],
+        });
+        logger.info(`${LOG_PREFIX} OTLP log exporter added — LoggerProvider created`, {
+            endpoint: `${otlpEndpoint}/v1/logs`,
+            serviceName,
+        });
+    }
+    catch (logsError) {
+        logger.warn(`${LOG_PREFIX} Failed to create OTLP log exporter (non-fatal)`, {
+            error: logsError instanceof Error ? logsError.message : String(logsError),
+            endpoint: otlpEndpoint,
+        });
+    }
+}
 const contextStorage = new AsyncLocalStorage();
 let tracerProvider = null;
+let meterProvider = null;
+let loggerProvider = null;
 let langfuseProcessor = null;
 let isInitialized = false;
 let isCredentialsValid = false;
@@ -328,48 +403,20 @@ class ContextEnricher {
         return Promise.resolve();
     }
 }
-/**
- * Initialize OpenTelemetry with Langfuse span processor
- *
- * This connects Vercel AI SDK's experimental_telemetry to Langfuse by:
- * 1. Creating LangfuseSpanProcessor with Langfuse credentials
- * 2. Creating a NodeTracerProvider with service metadata and span processor
- * 3. Registering the provider globally for AI SDK to use
- *
- * NEW: If useExternalTracerProvider is true or autoDetectExternalProvider detects
- * an existing provider, steps 2 and 3 are skipped. The span processors are still
- * created and can be retrieved via getSpanProcessors().
- *
- * @param config - Langfuse configuration passed from parent application
- */
-export function initializeOpenTelemetry(config) {
-    // Guard against multiple initializations — but always update config
-    // so that later NeuroLink instances can change traceNameFormat,
-    // autoDetectOperationName, and other configuration preferences
-    // without re-initializing the OTEL infrastructure.
-    if (isInitialized) {
-        currentConfig = config;
-        logger.debug(`${LOG_PREFIX} Already initialized, config updated`, {
-            usingExternalProvider,
-            hasLangfuseProcessor: !!langfuseProcessor,
-            hasTraceNameFormat: typeof config.traceNameFormat === "function",
-        });
-        return;
-    }
-    // FIRST: Check for external provider mode - bypasses enabled check
-    // NOTE: When autoDetectExternalProvider is true, we trust the flag directly rather than
-    // calling hasExternalTracerProvider(). This is because Neurolink may bundle its own copy
-    // of @opentelemetry/api, which has a separate global state from the host application.
-    // The hasExternalTracerProvider() check would query Neurolink's bundled @opentelemetry/api
-    // global state (which has no provider registered), not the host's global state.
-    // By trusting autoDetectExternalProvider=true, we let the host application signal that
-    // it has already registered a TracerProvider.
-    const shouldUseExternal = config?.useExternalTracerProvider === true ||
-        config?.autoDetectExternalProvider === true;
-    if (shouldUseExternal) {
-        // Validate credentials even in external mode
-        if (!config?.publicKey || !config?.secretKey) {
-            logger.warn(`${LOG_PREFIX} External provider mode but missing credentials, skipping initialization`, {
+function createLangfuseProcessor(config) {
+    return new LangfuseSpanProcessor({
+        publicKey: config.publicKey,
+        secretKey: config.secretKey,
+        baseUrl: config.baseUrl || "https://cloud.langfuse.com",
+        environment: config.environment || "dev",
+        release: config.release || "v1.0.0",
+        shouldExportSpan: () => true,
+    });
+}
+function initializeExternalOpenTelemetryMode(config, resource, otlpEndpoint, serviceName, langfuseRequested, hasLangfuseCreds) {
+    if (langfuseRequested && !hasLangfuseCreds) {
+        if (!otlpEndpoint) {
+            logger.warn(`${LOG_PREFIX} External provider mode requested Langfuse but credentials are missing, and no OTLP endpoint is configured; skipping initialization`, {
                 hasPublicKey: !!config?.publicKey,
                 hasSecretKey: !!config?.secretKey,
             });
@@ -377,154 +424,164 @@ export function initializeOpenTelemetry(config) {
             isCredentialsValid = false;
             return;
         }
+        logger.warn(`${LOG_PREFIX} External provider mode missing Langfuse credentials; continuing with OTLP-only metrics/logs`, {
+            hasPublicKey: !!config?.publicKey,
+            hasSecretKey: !!config?.secretKey,
+            otlpEnabled: true,
+        });
+    }
+    try {
+        currentConfig = config;
+        isCredentialsValid = hasLangfuseCreds;
+        langfuseProcessor =
+            langfuseRequested && hasLangfuseCreds
+                ? createLangfuseProcessor(config)
+                : null;
+        usingExternalProvider = true;
+        isInitialized = true;
+        initializeOtlpMetricsAndLogs(resource, otlpEndpoint, serviceName);
         try {
-            currentConfig = config;
-            isCredentialsValid = true;
-            // Create span processor for external provider mode
-            // shouldExportSpan: export all spans (v5 default filters to gen_ai spans only)
-            langfuseProcessor = new LangfuseSpanProcessor({
-                publicKey: config.publicKey,
-                secretKey: config.secretKey,
-                baseUrl: config.baseUrl || "https://cloud.langfuse.com",
-                environment: config.environment || "dev",
-                release: config.release || "v1.0.0",
-                shouldExportSpan: () => true,
-            });
-            usingExternalProvider = true;
-            isInitialized = true;
-            // Auto-register ContextEnricher with the global TracerProvider
-            // This ensures trace names are set even when host doesn't call getSpanProcessors()
-            try {
-                const globalProvider = trace.getTracerProvider();
-                // Check if it's a real provider with addSpanProcessor method (not the no-op default)
-                if (globalProvider &&
-                    typeof globalProvider
-                        .addSpanProcessor === "function") {
-                    const provider = globalProvider;
-                    // Add ContextEnricher for trace name enrichment
-                    provider.addSpanProcessor(new ContextEnricher());
-                    // Only add LangfuseSpanProcessor if the host has not already registered one.
-                    // When skipLangfuseSpanProcessor is true, the host (e.g. Curator) already
-                    // registers its own LangfuseSpanProcessor via a DeferredSpanProcessor, so
-                    // adding another one here would cause duplicate trace exports to Langfuse.
-                    const skipLangfuse = config.skipLangfuseSpanProcessor === true;
-                    if (!skipLangfuse) {
-                        provider.addSpanProcessor(langfuseProcessor);
-                    }
-                    logger.info(`${LOG_PREFIX} Auto-registered processors with global TracerProvider`, {
-                        processors: skipLangfuse
-                            ? ["ContextEnricher"]
-                            : ["ContextEnricher", "LangfuseSpanProcessor"],
-                        reason: "External provider mode with auto-registration",
-                        skippedLangfuseSpanProcessor: skipLangfuse,
-                    });
-                }
-                else {
-                    // No real provider found - host will need to add processors manually
-                    logger.info(`${LOG_PREFIX} Using external TracerProvider mode`, {
-                        reason: config.useExternalTracerProvider
-                            ? "useExternalTracerProvider=true"
-                            : "autoDetectExternalProvider=true (trusting host signal)",
-                        instructions: "Add span processors to your TracerProvider using getSpanProcessors()",
-                    });
-                    logger.info(`${LOG_PREFIX} Span processors ready for external use`, {
-                        processors: ["ContextEnricher", "LangfuseSpanProcessor"],
-                        usage: "import { getSpanProcessors } from '@juspay/neurolink'",
-                    });
+            const globalProvider = trace.getTracerProvider();
+            const provider = globalProvider;
+            if (globalProvider && typeof provider.addSpanProcessor === "function") {
+                provider.addSpanProcessor(new ContextEnricher());
+                const skipLangfuse = config.skipLangfuseSpanProcessor === true || !langfuseProcessor;
+                if (!skipLangfuse && langfuseProcessor) {
+                    provider.addSpanProcessor(langfuseProcessor);
                 }
-            }
-            catch (autoRegisterError) {
-                // Auto-registration failed - fall back to manual registration
-                logger.warn(`${LOG_PREFIX} Auto-registration failed, manual registration required`, {
-                    error: autoRegisterError instanceof Error
-                        ? autoRegisterError.message
-                        : String(autoRegisterError),
-                    instructions: "Add span processors to your TracerProvider using getSpanProcessors()",
+                logger.info(`${LOG_PREFIX} Auto-registered processors with global TracerProvider`, {
+                    processors: skipLangfuse
+                        ? ["ContextEnricher"]
+                        : ["ContextEnricher", "LangfuseSpanProcessor"],
+                    reason: "External provider mode with auto-registration",
+                    skippedLangfuseSpanProcessor: skipLangfuse,
                 });
+                return;
             }
-            return;
+            logger.info(`${LOG_PREFIX} Using external TracerProvider mode`, {
+                reason: config.useExternalTracerProvider
+                    ? "useExternalTracerProvider=true"
+                    : "autoDetectExternalProvider=true (trusting host signal)",
+                instructions: "Add span processors to your TracerProvider using getSpanProcessors()",
+            });
+            logger.info(`${LOG_PREFIX} Span processors ready for external use`, {
+                processors: langfuseProcessor
+                    ? ["ContextEnricher", "LangfuseSpanProcessor"]
+                    : ["ContextEnricher"],
+                usage: "import { getSpanProcessors } from '@juspay/neurolink'",
+            });
         }
-        catch (error) {
-            logger.error(`${LOG_PREFIX} Failed to create span processor for external mode`, {
-                error: error instanceof Error ? error.message : String(error),
-                stack: error instanceof Error ? error.stack : undefined,
+        catch (autoRegisterError) {
+            logger.warn(`${LOG_PREFIX} Auto-registration failed, manual registration required`, {
+                error: autoRegisterError instanceof Error
+                    ? autoRegisterError.message
+                    : String(autoRegisterError),
+                instructions: "Add span processors to your TracerProvider using getSpanProcessors()",
             });
-            isInitialized = true;
-            return;
         }
     }
-    // THEN: Check enabled for standalone mode
-    if (!config?.enabled) {
-        logger.debug(`${LOG_PREFIX} Langfuse disabled and no external provider, skipping initialization`);
+    catch (error) {
+        logger.error(`${LOG_PREFIX} Failed to create span processor for external mode`, {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined,
+        });
+        isInitialized = true;
+    }
+}
+function initializeStandaloneOpenTelemetryMode(config, resource, otlpEndpoint, serviceName, langfuseRequested, hasLangfuseCreds) {
+    if ((!langfuseRequested || !hasLangfuseCreds) && !otlpEndpoint) {
+        if (langfuseRequested && !hasLangfuseCreds) {
+            logger.warn(`${LOG_PREFIX} Langfuse requested but credentials are missing, and no OTLP endpoint is configured; skipping initialization`, {
+                hasPublicKey: !!config.publicKey,
+                hasSecretKey: !!config.secretKey,
+            });
+        }
+        else {
+            logger.debug(`${LOG_PREFIX} Langfuse disabled and OTLP endpoint missing, skipping initialization`);
+        }
         isInitialized = true;
         return;
     }
-    // Validate credentials for standalone mode
-    if (!config.publicKey || !config.secretKey) {
-        logger.warn(`${LOG_PREFIX} Langfuse enabled but missing credentials, skipping initialization`, {
+    if (langfuseRequested && !hasLangfuseCreds) {
+        logger.warn(`${LOG_PREFIX} Langfuse requested but credentials are missing; continuing with OTLP-only telemetry`, {
             hasPublicKey: !!config.publicKey,
             hasSecretKey: !!config.secretKey,
+            otlpEnabled: !!otlpEndpoint,
         });
-        isInitialized = true;
-        isCredentialsValid = false;
-        return;
     }
     try {
         currentConfig = config;
-        isCredentialsValid = true;
-        // Step 1: Create LangfuseSpanProcessor for standalone mode
-        // shouldExportSpan: export all spans (v5 default filters to gen_ai spans only)
-        langfuseProcessor = new LangfuseSpanProcessor({
-            publicKey: config.publicKey,
-            secretKey: config.secretKey,
-            baseUrl: config.baseUrl || "https://cloud.langfuse.com",
-            environment: config.environment || "dev",
-            release: config.release || "v1.0.0",
-            shouldExportSpan: () => true,
-        });
-        logger.debug(`${LOG_PREFIX} Created LangfuseSpanProcessor`, {
+        isCredentialsValid = hasLangfuseCreds;
+        langfuseProcessor =
+            langfuseRequested && hasLangfuseCreds
+                ? createLangfuseProcessor(config)
+                : null;
+        logger.debug(`${LOG_PREFIX} Standalone observability mode`, {
+            langfuseEnabled: !!langfuseProcessor,
+            otlpEnabled: !!otlpEndpoint,
             baseUrl: config.baseUrl || "https://cloud.langfuse.com",
             environment: config.environment || "dev",
         });
-        // Step 2: Create our own TracerProvider (standalone behavior)
-        const resource = resourceFromAttributes({
-            [ATTR_SERVICE_NAME]: "neurolink",
-            [ATTR_SERVICE_VERSION]: config.release || "v1.0.0",
-            "deployment.environment": config.environment || "dev",
-        });
-        tracerProvider = new NodeTracerProvider({
-            resource,
-            spanProcessors: [new ContextEnricher(), langfuseProcessor],
+        const spanProcessors = [new ContextEnricher()];
+        if (langfuseProcessor) {
+            spanProcessors.push(langfuseProcessor);
+        }
+        if (otlpEndpoint) {
+            try {
+                const otlpExporter = new OTLPTraceExporter({
+                    url: `${otlpEndpoint}/v1/traces`,
+                });
+                spanProcessors.push(new BatchSpanProcessor(otlpExporter, {
+                    maxQueueSize: 2048,
+                    maxExportBatchSize: 512,
+                    scheduledDelayMillis: 1000,
+                    exportTimeoutMillis: 30000,
+                }));
+                logger.info(`${LOG_PREFIX} OTLP trace exporter added`, {
+                    endpoint: `${otlpEndpoint}/v1/traces`,
+                    serviceName,
+                });
+            }
+            catch (otlpError) {
+                logger.warn(`${LOG_PREFIX} Failed to create OTLP exporter (non-fatal)`, {
+                    error: otlpError instanceof Error
+                        ? otlpError.message
+                        : String(otlpError),
+                    endpoint: otlpEndpoint,
+                });
+            }
+        }
+        tracerProvider = new NodeTracerProvider({ resource, spanProcessors });
+        tracerProvider.register({
+            propagator: new W3CTraceContextPropagator(),
         });
-        // Step 4: Register globally
-        tracerProvider.register();
         usingExternalProvider = false;
         isInitialized = true;
-        logger.info(`${LOG_PREFIX} Initialized with Langfuse span processor`, {
+        initializeOtlpMetricsAndLogs(resource, otlpEndpoint, serviceName);
+        logger.info(`${LOG_PREFIX} Observability initialized`, {
             baseUrl: config.baseUrl || "https://cloud.langfuse.com",
             environment: config.environment || "dev",
             release: config.release || "v1.0.0",
             mode: "standalone",
+            langfuseEnabled: !!langfuseProcessor,
+            otlpEnabled: !!otlpEndpoint,
+            serviceName,
         });
     }
     catch (error) {
-        // Check if this is a duplicate registration error
         const errorMessage = error instanceof Error ? error.message : String(error);
         const isDuplicateError = errorMessage.includes("duplicate registration") ||
             errorMessage.includes("already registered") ||
             errorMessage.includes("already set");
         if (isDuplicateError) {
-            // Graceful handling: switch to external mode
             logger.warn(`${LOG_PREFIX} TracerProvider already registered, switching to external mode`, {
                 error: errorMessage,
                 recommendation: "Set useExternalTracerProvider=true or autoDetectExternalProvider=true in config",
             });
             usingExternalProvider = true;
             isInitialized = true;
-            // Don't throw - processors are still usable
             return;
         }
-        // Other errors: log and re-throw
         logger.error(`${LOG_PREFIX} Initialization failed`, {
             error: errorMessage,
             stack: error instanceof Error ? error.stack : undefined,
@@ -532,6 +589,55 @@ export function initializeOpenTelemetry(config) {
         throw error;
     }
 }
+/**
+ * Initialize OpenTelemetry with Langfuse span processor
+ *
+ * This connects Vercel AI SDK's experimental_telemetry to Langfuse by:
+ * 1. Creating LangfuseSpanProcessor with Langfuse credentials
+ * 2. Creating a NodeTracerProvider with service metadata and span processor
+ * 3. Registering the provider globally for AI SDK to use
+ *
+ * NEW: If useExternalTracerProvider is true or autoDetectExternalProvider detects
+ * an existing provider, steps 2 and 3 are skipped. The span processors are still
+ * created and can be retrieved via getSpanProcessors().
+ *
+ * @param config - Langfuse configuration passed from parent application
+ */
+export function initializeOpenTelemetry(config) {
+    // Guard against multiple initializations — but always update config
+    // so that later NeuroLink instances can change traceNameFormat,
+    // autoDetectOperationName, and other configuration preferences
+    // without re-initializing the OTEL infrastructure.
+    if (isInitialized) {
+        currentConfig = config;
+        logger.debug(`${LOG_PREFIX} Already initialized, config updated`, {
+            usingExternalProvider,
+            hasLangfuseProcessor: !!langfuseProcessor,
+            hasTraceNameFormat: typeof config.traceNameFormat === "function",
+        });
+        return;
+    }
+    // FIRST: Check for external provider mode - bypasses enabled check
+    // NOTE: When autoDetectExternalProvider is true, we trust the flag directly rather than
+    // calling hasExternalTracerProvider(). This is because Neurolink may bundle its own copy
+    // of @opentelemetry/api, which has a separate global state from the host application.
+    // The hasExternalTracerProvider() check would query Neurolink's bundled @opentelemetry/api
+    // global state (which has no provider registered), not the host's global state.
+    // By trusting autoDetectExternalProvider=true, we let the host application signal that
+    // it has already registered a TracerProvider.
+    const shouldUseExternal = config?.useExternalTracerProvider === true ||
+        config?.autoDetectExternalProvider === true;
+    const otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+    const langfuseRequested = config?.enabled === true;
+    const hasLangfuseCreds = !!config.publicKey && !!config.secretKey;
+    const serviceName = process.env.OTEL_SERVICE_NAME || "neurolink";
+    const resource = createOtelResource(config, serviceName);
+    if (shouldUseExternal) {
+        initializeExternalOpenTelemetryMode(config, resource, otlpEndpoint, serviceName, langfuseRequested, hasLangfuseCreds);
+        return;
+    }
+    initializeStandaloneOpenTelemetryMode(config, resource, otlpEndpoint, serviceName, langfuseRequested, hasLangfuseCreds);
+}
 /**
  * Flush all pending spans to Langfuse
  */
@@ -540,22 +646,75 @@ export async function flushOpenTelemetry() {
         logger.debug(`${LOG_PREFIX} Not initialized, skipping flush`);
         return;
     }
-    if (!langfuseProcessor) {
-        logger.debug(`${LOG_PREFIX} No processor to flush (Langfuse disabled)`);
-        return;
+    const failures = [];
+    if (langfuseProcessor) {
+        try {
+            logger.info(`${LOG_PREFIX} Flushing Langfuse spans...`);
+            await langfuseProcessor.forceFlush();
+        }
+        catch (error) {
+            failures.push({ signal: "langfuse", error });
+            logger.error(`${LOG_PREFIX} Langfuse flush failed`, {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
     }
-    try {
-        logger.info(`${LOG_PREFIX} Flushing pending spans to Langfuse...`);
-        await langfuseProcessor.forceFlush();
-        logger.info(`${LOG_PREFIX} Successfully flushed spans to Langfuse`);
+    else {
+        logger.debug(`${LOG_PREFIX} Langfuse disabled, skipping Langfuse flush`);
     }
-    catch (error) {
-        logger.error(`${LOG_PREFIX} Flush failed`, {
-            error: error instanceof Error ? error.message : String(error),
-            stack: error instanceof Error ? error.stack : undefined,
-        });
-        throw error;
+    if (tracerProvider && !usingExternalProvider) {
+        try {
+            logger.info(`${LOG_PREFIX} Flushing OTLP traces...`);
+            await tracerProvider.forceFlush();
+        }
+        catch (error) {
+            failures.push({ signal: "traces", error });
+            logger.error(`${LOG_PREFIX} Trace flush failed`, {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
     }
+    else {
+        logger.debug(`${LOG_PREFIX} No TracerProvider to flush`);
+    }
+    if (meterProvider) {
+        try {
+            logger.info(`${LOG_PREFIX} Flushing OTLP metrics...`);
+            await meterProvider.forceFlush();
+        }
+        catch (error) {
+            failures.push({ signal: "metrics", error });
+            logger.error(`${LOG_PREFIX} Metric flush failed`, {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
+    }
+    else {
+        logger.debug(`${LOG_PREFIX} No MeterProvider to flush`);
+    }
+    if (loggerProvider) {
+        try {
+            logger.info(`${LOG_PREFIX} Flushing OTLP logs...`);
+            await loggerProvider.forceFlush();
+        }
+        catch (error) {
+            failures.push({ signal: "logs", error });
+            logger.error(`${LOG_PREFIX} Log flush failed`, {
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
+    }
+    else {
+        logger.debug(`${LOG_PREFIX} No LoggerProvider to flush`);
+    }
+    if (failures.length > 0) {
+        throw new Error(`${LOG_PREFIX} Flush failed for: ${failures.map((f) => f.signal).join(", ")}`);
+    }
+    logger.info(`${LOG_PREFIX} Flush complete`);
 }
 /**
  * Shutdown OpenTelemetry and Langfuse span processor
@@ -577,7 +736,17 @@ export async function shutdownOpenTelemetry() {
         if (cachedContextEnricher) {
             await cachedContextEnricher.shutdown();
         }
+        // Shutdown MeterProvider if we created it
+        if (meterProvider) {
+            await meterProvider.shutdown();
+        }
+        // Shutdown LoggerProvider if we created it
+        if (loggerProvider) {
+            await loggerProvider.shutdown();
+        }
         tracerProvider = null;
+        meterProvider = null;
+        loggerProvider = null;
         langfuseProcessor = null;
         cachedContextEnricher = null;
         isInitialized = false;
@@ -603,6 +772,13 @@ export function getLangfuseSpanProcessor() {
 export function getTracerProvider() {
     return tracerProvider;
 }
+/**
+ * Get the logger provider for emitting OTLP log records.
+ * Returns null if OTLP is not configured or LoggerProvider was not created.
+ */
+export function getLoggerProvider() {
+    return loggerProvider;
+}
 /**
  * Check if OpenTelemetry is initialized
  */

package/dist/lib/tasks/backends/bullmqBackend.d.ts

@@ -29,4 +29,5 @@ export declare class BullMQBackend implements TaskBackend {
      */
     private getConnectionConfig;
     private ensureInitialized;
+    private getQueue;
 }