@juspay/neurolink 9.42.0 → 9.43.0

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

@@ -21,6 +21,72 @@ import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from "@opentelemetry/semanti
 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;
@@ -337,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,
             });
@@ -386,86 +424,71 @@ 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;
         }
     }
-    const otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
-    const langfuseRequested = config?.enabled === true;
-    const hasLangfuseCreds = !!config.publicKey && !!config.secretKey;
-    // THEN: Check whether we have any standalone observability backend at all.
+    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`, {
@@ -489,55 +512,31 @@ export function initializeOpenTelemetry(config) {
     try {
         currentConfig = config;
         isCredentialsValid = hasLangfuseCreds;
-        // Step 1: Create LangfuseSpanProcessor only when Langfuse is explicitly enabled
-        // with real credentials. OTLP-only mode is valid and should not construct one.
-        if (langfuseRequested && hasLangfuseCreds) {
-            // 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,
-            });
-        }
-        else {
-            langfuseProcessor = null;
-        }
+        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)
-        // Use OTEL_SERVICE_NAME env var if available, otherwise "neurolink"
-        const serviceName = process.env.OTEL_SERVICE_NAME || "neurolink";
-        const resource = resourceFromAttributes({
-            [ATTR_SERVICE_NAME]: serviceName,
-            [ATTR_SERVICE_VERSION]: config.release || "v1.0.0",
-            "deployment.environment": config.environment || "dev",
-        });
-        // Build span processor list
         const spanProcessors = [new ContextEnricher()];
         if (langfuseProcessor) {
             spanProcessors.push(langfuseProcessor);
         }
-        // Step 2b: If OTEL_EXPORTER_OTLP_ENDPOINT is set, also export via OTLP HTTP
-        // This allows sending traces to an OpenTelemetry Collector (e.g. for OpenObserve)
         if (otlpEndpoint) {
             try {
                 const otlpExporter = new OTLPTraceExporter({
                     url: `${otlpEndpoint}/v1/traces`,
                 });
-                const otlpBatchProcessor = new BatchSpanProcessor(otlpExporter, {
+                spanProcessors.push(new BatchSpanProcessor(otlpExporter, {
                     maxQueueSize: 2048,
                     maxExportBatchSize: 512,
                     scheduledDelayMillis: 1000,
                     exportTimeoutMillis: 30000,
-                });
-                spanProcessors.push(otlpBatchProcessor);
+                }));
                 logger.info(`${LOG_PREFIX} OTLP trace exporter added`, {
                     endpoint: `${otlpEndpoint}/v1/traces`,
                     serviceName,
@@ -552,81 +551,13 @@ export function initializeOpenTelemetry(config) {
                 });
             }
         }
-        tracerProvider = new NodeTracerProvider({
-            resource,
-            spanProcessors,
-        });
-        // Step 4: Register globally with explicit W3C propagator
-        // This ensures traceparent headers from calling SDKs are extracted correctly,
-        // even if another library registers a no-op propagator before us.
+        tracerProvider = new NodeTracerProvider({ resource, spanProcessors });
         tracerProvider.register({
             propagator: new W3CTraceContextPropagator(),
         });
         usingExternalProvider = false;
         isInitialized = true;
-        // Step 5: If OTLP endpoint is set, also set up MeterProvider for metrics export
-        // This enables TelemetryService's metrics.getMeter() instruments to export via OTLP
-        if (otlpEndpoint) {
-            try {
-                const metricExporter = new OTLPMetricExporter({
-                    url: `${otlpEndpoint}/v1/metrics`,
-                });
-                const metricReader = new PeriodicExportingMetricReader({
-                    exporter: metricExporter,
-                    exportIntervalMillis: 15000, // Export every 15 seconds
-                    exportTimeoutMillis: 10000,
-                });
-                meterProvider = new MeterProvider({
-                    resource,
-                    readers: [metricReader],
-                });
-                // Register globally so TelemetryService's metrics.getMeter() picks it up
-                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,
-                });
-            }
-            // Step 6: Set up LoggerProvider for OTLP log export
-            // This enables logRequest() to emit structured log records via OTLP
-            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,
-                });
-            }
-        }
+        initializeOtlpMetricsAndLogs(resource, otlpEndpoint, serviceName);
         logger.info(`${LOG_PREFIX} Observability initialized`, {
             baseUrl: config.baseUrl || "https://cloud.langfuse.com",
             environment: config.environment || "dev",
@@ -638,23 +569,19 @@ export function initializeOpenTelemetry(config) {
         });
     }
     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,
@@ -662,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
  */

package/dist/lib/tasks/backends/bullmqBackend.js

@@ -64,28 +64,34 @@ export class BullMQBackend {
     async schedule(task, executor) {
         const queue = this.getQueue();
         this.executors.set(task.id, executor);
-        const jobData = { taskId: task.id, task };
-        const schedule = task.schedule;
-        if (schedule.type === "cron") {
-            await queue.upsertJobScheduler(task.id, {
-                pattern: schedule.expression,
-                ...(schedule.timezone ? { tz: schedule.timezone } : {}),
-            }, { name: task.name, data: jobData });
-        }
-        else if (schedule.type === "interval") {
-            await queue.upsertJobScheduler(task.id, { every: schedule.every }, { name: task.name, data: jobData });
+        try {
+            const jobData = { taskId: task.id, task };
+            const schedule = task.schedule;
+            if (schedule.type === "cron") {
+                await queue.upsertJobScheduler(task.id, {
+                    pattern: schedule.expression,
+                    ...(schedule.timezone ? { tz: schedule.timezone } : {}),
+                }, { name: task.name, data: jobData });
+            }
+            else if (schedule.type === "interval") {
+                await queue.upsertJobScheduler(task.id, { every: schedule.every }, { name: task.name, data: jobData });
+            }
+            else if (schedule.type === "once") {
+                const at = typeof schedule.at === "string" ? new Date(schedule.at) : schedule.at;
+                const delay = Math.max(0, at.getTime() - Date.now());
+                await queue.add(task.name, jobData, {
+                    jobId: task.id,
+                    delay,
+                });
+            }
         }
-        else if (schedule.type === "once") {
-            const at = typeof schedule.at === "string" ? new Date(schedule.at) : schedule.at;
-            const delay = Math.max(0, at.getTime() - Date.now());
-            await queue.add(task.name, jobData, {
-                jobId: task.id,
-                delay,
-            });
+        catch (error) {
+            this.executors.delete(task.id);
+            throw error;
         }
         logger.info("[BullMQ] Task scheduled", {
             taskId: task.id,
-            type: schedule.type,
+            type: task.schedule.type,
         });
     }
     async cancel(taskId) {

package/dist/lib/tasks/store/redisTaskStore.js

@@ -63,7 +63,7 @@ export class RedisTaskStore {
     async save(task) {
         const client = this.getClient();
         await client.hSet(TASKS_HASH, task.id, JSON.stringify(task));
-        this.applyRetentionTTL(task);
+        this.applyRetentionTTL(task, client);
     }
     async get(taskId) {
         const client = this.getClient();
@@ -95,7 +95,7 @@ export class RedisTaskStore {
             updatedAt: new Date().toISOString(),
         };
         await client.hSet(TASKS_HASH, taskId, JSON.stringify(updated));
-        this.applyRetentionTTL(updated);
+        this.applyRetentionTTL(updated, client);
         return updated;
     }
     async delete(taskId) {
@@ -167,7 +167,7 @@ export class RedisTaskStore {
      * Set Redis TTL on terminal-state tasks so they auto-expire.
      * Active and paused tasks never expire.
      */
-    applyRetentionTTL(task) {
+    applyRetentionTTL(task, client) {
         // We don't set EXPIRE on the hash field directly (Redis doesn't support per-field TTL).
         // Instead, run logs and history keys get TTL. The task hash field itself must be
         // cleaned up via manual deletion or BullMQ's built-in job cleanup.
@@ -177,21 +177,46 @@ export class RedisTaskStore {
             cancelled: this.retentionConfig.cancelledTTL,
         };
         const ttlMs = ttlMap[task.status];
-        if (ttlMs) {
-            const client = this.getClient();
-            const ttlSeconds = Math.ceil(ttlMs / 1000);
-            // Set TTL on associated keys
-            client.expire(taskRunsKey(task.id), ttlSeconds).catch((err) => {
-                logger.debug("[TaskStore:Redis] Failed to set TTL", {
-                    error: String(err),
-                });
-            });
-            client.expire(taskHistoryKey(task.id), ttlSeconds).catch((err) => {
-                logger.debug("[TaskStore:Redis] Failed to set TTL", {
-                    error: String(err),
-                });
-            });
+        if (!ttlMs || !client.isOpen) {
+            return;
         }
+        const ttlSeconds = Math.ceil(ttlMs / 1000);
+        // Set TTL on associated keys best-effort. A successful task write should not
+        // be surfaced as a failure just because the retention metadata could not be updated.
+        void (async () => {
+            const runsKey = taskRunsKey(task.id);
+            for (let attempt = 1; attempt <= 3; attempt++) {
+                try {
+                    await client.expire(runsKey, ttlSeconds);
+                    break;
+                }
+                catch (err) {
+                    if (attempt === 3) {
+                        logger.warn("[TaskStore:Redis] expire failed after 3 attempts on task runs key — task data may outlive retention window", { taskId: task.id, key: runsKey, ttlSeconds, err: String(err) });
+                    }
+                    else {
+                        await new Promise((r) => setTimeout(r, 100 * attempt));
+                    }
+                }
+            }
+        })();
+        void (async () => {
+            const histKey = taskHistoryKey(task.id);
+            for (let attempt = 1; attempt <= 3; attempt++) {
+                try {
+                    await client.expire(histKey, ttlSeconds);
+                    break;
+                }
+                catch (err) {
+                    if (attempt === 3) {
+                        logger.warn("[TaskStore:Redis] expire failed after 3 attempts on task history key — task data may outlive retention window", { taskId: task.id, key: histKey, ttlSeconds, err: String(err) });
+                    }
+                    else {
+                        await new Promise((r) => setTimeout(r, 100 * attempt));
+                    }
+                }
+            }
+        })();
     }
 }
 //# sourceMappingURL=redisTaskStore.js.map

package/dist/lib/tasks/taskManager.d.ts

@@ -49,6 +49,8 @@ export declare class TaskManager {
     shutdown(): Promise<void>;
     /** Check if the backend is healthy */
     isHealthy(): Promise<boolean>;
+    private restoreScheduledTask;
+    private rollbackTaskUpdate;
     /**
      * Called by the backend on each scheduled tick.
      * Executes the task, updates state, fires callbacks/events.