@open-mercato/queue 0.6.7-develop.6862.1.c11a64ce0a → 0.6.7

package/src/worker/runner.ts

@@ -1,9 +1,5 @@
 import { createQueue } from '../factory'
 import { createLogger } from '@open-mercato/shared/lib/logger'
-import {
-  getTelemetryRuntime,
-  isTelemetryBackendEnabled,
-} from '@open-mercato/shared/lib/telemetry/runtime'
 import type { Queue, JobHandler, AsyncQueueOptions, QueueStrategyType } from '../types'
 
 const logger = createLogger('queue').child({ component: 'worker' })
@@ -20,10 +16,6 @@ export type WorkerRunnerOptions<T = unknown> = {
   connection?: AsyncQueueOptions['connection']
   /** Number of concurrent jobs to process */
   concurrency?: number
-  /** How long a job lock is held before the job counts as stalled, in ms. */
-  lockDuration?: number
-  /** Number of stalled-job recoveries BullMQ permits before failing a job. */
-  maxStalledCount?: number
   /** Whether to set up graceful shutdown handlers */
   gracefulShutdown?: boolean
   /** If true, don't block - return immediately after starting processing (for multi-queue mode) */
@@ -75,17 +67,6 @@ function registerShutdownHandlers(): void {
     unregisterShutdownHandlers(sigtermHandler, sigintHandler)
     shutdownInProgress = false
 
-    // Flush buffered spans/logs before the process dies. A worker never returns
-    // from run(), so bin.ts's post-run shutdownTelemetry() is unreachable on this
-    // path — without this, the BatchSpanProcessor's ~5s tail is dropped on every
-    // restart/redeploy. Idempotent and a no-op when telemetry is off; a flush
-    // failure must not turn a clean shutdown into a failed one.
-    try {
-      await getTelemetryRuntime()?.shutdown()
-    } catch (error) {
-      logger.error('Error flushing telemetry during shutdown', { err: error })
-    }
-
     if (!hasError) {
       logger.info('Worker closed successfully')
     }
@@ -149,22 +130,11 @@ export async function runWorker<T = unknown>(
     handler,
     connection,
     concurrency = 1,
-    lockDuration,
-    maxStalledCount,
     gracefulShutdown = true,
     background = false,
     strategy: strategyOption,
   } = options
 
-  // Worker processes don't run Next's instrumentation hook, so initialize
-  // telemetry here — this is the single bootstrap every standalone worker passes
-  // through. Import the telemetry package only for an explicit enabled backend;
-  // with the default/unset backend the worker never evaluates the package.
-  if (!getTelemetryRuntime() && isTelemetryBackendEnabled()) {
-    const { initTelemetry } = await import('@open-mercato/telemetry')
-    await initTelemetry()
-  }
-
   // Determine queue strategy from option, env var, or default to 'local'
   const strategy: QueueStrategyType = strategyOption
     ?? (process.env.QUEUE_STRATEGY === 'async' ? 'async' : 'local')
@@ -174,8 +144,6 @@ export async function runWorker<T = unknown>(
   const queue = createQueue<T>(queueName, strategy, {
     connection,
     concurrency,
-    lockDuration,
-    maxStalledCount,
   })
 
   // Set up graceful shutdown

package/dist/tracing.js

@@ -1,27 +0,0 @@
-import { getTelemetryRuntime } from "@open-mercato/shared/lib/telemetry/runtime";
-const TRACE_META_KEY = "_trace";
-function attachTraceMetadata(metadata) {
-  const carrier = getTelemetryRuntime()?.captureTraceContext() ?? {};
-  if (Object.keys(carrier).length === 0) return metadata;
-  return { ...metadata ?? {}, [TRACE_META_KEY]: carrier };
-}
-function runJobInTrace(queueName, metadata, fn) {
-  const runtime = getTelemetryRuntime();
-  if (!runtime) return fn();
-  return runtime.continueTrace(
-    readTraceCarrier(metadata),
-    `queue.${queueName}`,
-    fn,
-    { kind: "consumer" }
-  );
-}
-function readTraceCarrier(metadata) {
-  const raw = metadata?.[TRACE_META_KEY];
-  if (!raw || typeof raw !== "object") return void 0;
-  return raw;
-}
-export {
-  attachTraceMetadata,
-  runJobInTrace
-};
-//# sourceMappingURL=tracing.js.map

package/dist/tracing.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/tracing.ts"],
-  "sourcesContent": ["import { getTelemetryRuntime } from '@open-mercato/shared/lib/telemetry/runtime'\n\n/**\n * Distributed-trace propagation across the enqueue \u2192 worker boundary.\n *\n * The W3C trace carrier rides on the job's `metadata._trace` (a first-class\n * metadata channel, not the user payload). Both halves are automatic \u2014 the\n * strategies call `attachTraceMetadata` at enqueue and `runJobInTrace` at\n * dispatch \u2014 so a worker joins the enqueuing request's trace with no per-worker\n * code. Everything here is a cheap no-op when telemetry is off.\n *\n * This also covers anything that rides the queue: persistent event subscribers\n * (the event bus enqueues) and outbound webhook delivery (queued) become part of\n * the originating request's trace for free.\n */\nconst TRACE_META_KEY = '_trace'\n\n/**\n * Attach the active trace context to a job's metadata. Returns `metadata`\n * unchanged when telemetry is off (no active span \u2192 empty carrier), so jobs stay\n * clean unless tracing is active.\n */\nexport function attachTraceMetadata(\n  metadata: Record<string, unknown> | undefined,\n): Record<string, unknown> | undefined {\n  const carrier = getTelemetryRuntime()?.captureTraceContext() ?? {}\n  if (Object.keys(carrier).length === 0) return metadata\n  return { ...(metadata ?? {}), [TRACE_META_KEY]: carrier }\n}\n\n/**\n * Run a job handler inside a span (`queue.<queueName>`) that continues the\n * producer's trace from the carrier on `metadata`. With no carrier (or telemetry\n * off) it runs `fn` under a fresh root span \u2014 and a no-op when off. The span\n * ends when `fn` settles (sync or async).\n */\nexport function runJobInTrace<T>(\n  queueName: string,\n  metadata: Record<string, unknown> | undefined,\n  fn: () => T,\n): T {\n  const runtime = getTelemetryRuntime()\n  if (!runtime) return fn()\n  return runtime.continueTrace(\n    readTraceCarrier(metadata),\n    `queue.${queueName}`,\n    fn,\n    { kind: 'consumer' },\n  )\n}\n\nfunction readTraceCarrier(\n  metadata: Record<string, unknown> | undefined,\n): Record<string, string> | undefined {\n  const raw = metadata?.[TRACE_META_KEY]\n  if (!raw || typeof raw !== 'object') return undefined\n  return raw as Record<string, string>\n}\n"],
-  "mappings": "AAAA,SAAS,2BAA2B;AAepC,MAAM,iBAAiB;AAOhB,SAAS,oBACd,UACqC;AACrC,QAAM,UAAU,oBAAoB,GAAG,oBAAoB,KAAK,CAAC;AACjE,MAAI,OAAO,KAAK,OAAO,EAAE,WAAW,EAAG,QAAO;AAC9C,SAAO,EAAE,GAAI,YAAY,CAAC,GAAI,CAAC,cAAc,GAAG,QAAQ;AAC1D;AAQO,SAAS,cACd,WACA,UACA,IACG;AACH,QAAM,UAAU,oBAAoB;AACpC,MAAI,CAAC,QAAS,QAAO,GAAG;AACxB,SAAO,QAAQ;AAAA,IACb,iBAAiB,QAAQ;AAAA,IACzB,SAAS,SAAS;AAAA,IAClB;AAAA,IACA,EAAE,MAAM,WAAW;AAAA,EACrB;AACF;AAEA,SAAS,iBACP,UACoC;AACpC,QAAM,MAAM,WAAW,cAAc;AACrC,MAAI,CAAC,OAAO,OAAO,QAAQ,SAAU,QAAO;AAC5C,SAAO;AACT;",
-  "names": []
-}

package/src/__tests__/async.telemetry.test.ts

@@ -1,123 +0,0 @@
-// An OTLP backend must be active for the async strategy to delegate tracing to
-// bullmq-otel. Set before any module reads the (memoized) telemetry env, and
-// restored afterwards — process.env is shared across test files in the same
-// jest worker, and a leaked 'otlp' backend breaks sibling telemetry tests.
-const originalTelemetryBackend = process.env.TELEMETRY_BACKEND
-process.env.TELEMETRY_BACKEND = 'otlp'
-
-afterAll(() => {
-  if (originalTelemetryBackend === undefined) delete process.env.TELEMETRY_BACKEND
-  else process.env.TELEMETRY_BACKEND = originalTelemetryBackend
-})
-
-import { createQueue } from '../factory'
-import { getRedisUrlOrThrow } from '@open-mercato/shared/lib/redis/connection'
-import {
-  registerTelemetryRuntime,
-  resetTelemetryRuntime,
-} from '@open-mercato/shared/lib/telemetry/runtime'
-
-const queueCtor = jest.fn()
-const workerCtor = jest.fn()
-const queueAdd = jest.fn(async () => ({ id: 'bull-job-id' }))
-
-jest.mock('@open-mercato/shared/lib/redis/connection', () => ({
-  getRedisUrlOrThrow: jest.fn(),
-  parseRedisUrl: jest.requireActual('@open-mercato/shared/lib/redis/connection').parseRedisUrl,
-}))
-
-jest.mock('bullmq', () => {
-  class MockQueue<T> {
-    constructor(name: string, opts: unknown) {
-      queueCtor(name, opts)
-    }
-    add = queueAdd as unknown as (name: string, data: T, opts?: unknown) => Promise<{ id?: string }>
-    close = jest.fn(async () => {})
-    obliterate = jest.fn(async () => {})
-    getJobCounts = jest.fn(async () => ({ waiting: 0, active: 0, completed: 0, failed: 0 }))
-  }
-  class MockWorker<T> {
-    constructor(
-      name: string,
-      _processor: (job: { id?: string; data: T; attemptsMade: number }) => Promise<void>,
-      opts: unknown,
-    ) {
-      workerCtor(name, _processor, opts)
-    }
-    on = jest.fn()
-    close = jest.fn(async () => {})
-  }
-  return { Queue: MockQueue, Worker: MockWorker }
-})
-
-class MockBullMQOtel {
-  constructor(public readonly tracerName: string) {}
-}
-jest.mock('bullmq-otel', () => ({ BullMQOtel: MockBullMQOtel }))
-
-describe('Queue - async strategy telemetry wiring', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-    ;(getRedisUrlOrThrow as jest.MockedFunction<typeof getRedisUrlOrThrow>).mockReturnValue(
-      'rediss://default:secret@example.com:6380/1',
-    )
-    registerTelemetryRuntime({
-      canUseGlobalTracePropagation: () => true,
-      captureTraceContext: () => ({}),
-      continueTrace: (_carrier, _name, fn) => fn(),
-      recordHttpDuration: () => {},
-      reportError: () => {},
-      shutdown: async () => {},
-    })
-  })
-
-  afterEach(() => {
-    resetTelemetryRuntime()
-  })
-
-  it('wires bullmq-otel into BOTH the queue and worker when they resolve concurrently', async () => {
-    const queue = createQueue<{ value: number }>('trace-queue', 'async', { concurrency: 3 })
-
-    // Resolve enqueue (Queue) and process (Worker) concurrently: both hit the
-    // shared telemetry resolution at once. The memoized in-flight promise must
-    // hand both the SAME bullmq-otel instance — never one with, one without.
-    await Promise.all([queue.enqueue({ value: 1 }), queue.process(async () => {})])
-
-    const queueOpts = queueCtor.mock.calls[0]?.[1] as { telemetry?: unknown }
-    const workerOpts = workerCtor.mock.calls[0]?.[2] as { telemetry?: unknown }
-    expect(queueOpts.telemetry).toBeInstanceOf(MockBullMQOtel)
-    expect(workerOpts.telemetry).toBeInstanceOf(MockBullMQOtel)
-    expect(queueOpts.telemetry).toBe(workerOpts.telemetry)
-  })
-
-  it('omits the metadata._trace carrier when bullmq-otel owns propagation', async () => {
-    const queue = createQueue<{ value: number }>('trace-queue', 'async')
-
-    await queue.enqueue({ value: 42 })
-
-    const jobData = queueAdd.mock.calls[0]?.[1] as Record<string, unknown>
-    expect(jobData).not.toHaveProperty('metadata')
-  })
-
-  it('uses the dedicated carrier when global propagation is not explicitly trusted', async () => {
-    resetTelemetryRuntime()
-    registerTelemetryRuntime({
-      canUseGlobalTracePropagation: () => false,
-      captureTraceContext: () => ({ traceparent: 'secure-carrier' }),
-      continueTrace: (_carrier, _name, fn) => fn(),
-      recordHttpDuration: () => {},
-      reportError: () => {},
-      shutdown: async () => {},
-    })
-    const queue = createQueue<{ value: number }>('secure-trace-queue', 'async')
-
-    await queue.enqueue({ value: 7 })
-
-    const queueOpts = queueCtor.mock.calls[0]?.[1] as { telemetry?: unknown }
-    const jobData = queueAdd.mock.calls[0]?.[1] as {
-      metadata?: { _trace?: { traceparent?: string } }
-    }
-    expect(queueOpts.telemetry).toBeUndefined()
-    expect(jobData.metadata?._trace?.traceparent).toBe('secure-carrier')
-  })
-})

package/src/__tests__/tracing.test.ts

@@ -1,123 +0,0 @@
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { attachTraceMetadata, runJobInTrace } from '../tracing'
-import { createLocalQueue } from '../strategies/local'
-import { registerProvider, initTelemetry, shutdownTelemetry } from '@open-mercato/telemetry'
-import type { LogRecord, MetricPoint, Span, SpanOptions, TelemetryProvider, TraceCarrier } from '@open-mercato/telemetry'
-
-/**
- * Verifies the enqueue → worker trace handoff: the active context is captured
- * onto job metadata at enqueue, and the worker continues that trace at dispatch.
- * Uses a recording provider under the explicitly enabled console seam rather
- * than the real OTLP SDK.
- */
-const spanNames: string[] = []
-const remoteCarriers: TraceCarrier[] = []
-
-function noopSpan(): Span {
-  return { setAttribute() {}, setAttributes() {}, recordException() {}, setStatus() {}, end() {} }
-}
-
-const recordingProvider: TelemetryProvider = {
-  name: 'console',
-  supports: ['traces'],
-  async start() {},
-  async shutdown() {},
-  runInSpan<T>(name: string, _o: SpanOptions, fn: (s: Span) => T): T {
-    spanNames.push(name)
-    return fn(noopSpan())
-  },
-  activeSpan: () => undefined,
-  activeTraceContext: () => undefined,
-  inject: (carrier) => {
-    carrier.traceparent = 'test-traceparent'
-  },
-  runInRemoteSpan<T>(carrier: TraceCarrier, name: string, _o: SpanOptions, fn: (s: Span) => T): T {
-    remoteCarriers.push(carrier)
-    spanNames.push(name)
-    return fn(noopSpan())
-  },
-  emitLog: (_r: LogRecord) => {},
-  recordMetric: (_p: MetricPoint) => {},
-}
-
-beforeAll(async () => {
-  process.env.TELEMETRY_BACKEND = 'console'
-  registerProvider(recordingProvider)
-  await initTelemetry()
-})
-
-afterAll(async () => {
-  await shutdownTelemetry()
-  delete process.env.TELEMETRY_BACKEND
-})
-
-describe('queue trace propagation', () => {
-  it('attaches the active trace carrier to job metadata at enqueue', () => {
-    const metadata = attachTraceMetadata(undefined)
-    expect(metadata).toEqual({ _trace: { traceparent: 'test-traceparent' } })
-  })
-
-  it('preserves existing metadata while attaching the trace carrier', () => {
-    const metadata = attachTraceMetadata({ foo: 'bar' })
-    expect(metadata).toMatchObject({ foo: 'bar', _trace: { traceparent: 'test-traceparent' } })
-  })
-
-  it('continues the producer trace from job metadata at dispatch', async () => {
-    const result = await runJobInTrace('orders-process', { _trace: { traceparent: 'tp-123' } }, () =>
-      Promise.resolve('done'),
-    )
-    expect(result).toBe('done')
-    expect(remoteCarriers).toContainEqual({ traceparent: 'tp-123' })
-    expect(spanNames).toContain('queue.orders-process')
-  })
-
-  it('runs jobs without a carrier under a fresh span (no crash)', async () => {
-    const result = await runJobInTrace('orders-process', undefined, () => Promise.resolve(42))
-    expect(result).toBe(42)
-  })
-})
-
-/**
- * End-to-end through the REAL local strategy (file write + read + dispatch),
- * proving the headline acceptance criterion: a queued job continues the
- * enqueuing request's trace. This exercises the actual enqueue/dispatch wiring,
- * not just the helpers above.
- */
-describe('queue trace propagation (real local strategy)', () => {
-  let baseDir: string
-
-  beforeEach(() => {
-    baseDir = fs.mkdtempSync(path.join(os.tmpdir(), 'om-queue-trace-'))
-  })
-
-  afterEach(() => {
-    fs.rmSync(baseDir, { recursive: true, force: true })
-  })
-
-  it('persists the trace carrier on enqueue and continues it on dispatch', async () => {
-    const queue = createLocalQueue<{ orderId: string }>('orders-process', { baseDir })
-
-    await queue.enqueue({ orderId: 'o-1' })
-
-    // The carrier is written to the job's metadata — NOT the user payload.
-    const stored = JSON.parse(
-      fs.readFileSync(path.join(baseDir, 'orders-process', 'queue.json'), 'utf8'),
-    ) as Array<{ payload: unknown; metadata?: Record<string, unknown> }>
-    expect(stored[0].metadata).toEqual({ _trace: { traceparent: 'test-traceparent' } })
-    expect(stored[0].payload).toEqual({ orderId: 'o-1' })
-
-    let handlerRan = false
-    await queue.process((job) => {
-      handlerRan = true
-      // The handler still sees only its payload; the carrier is invisible to it.
-      expect(job.payload).toEqual({ orderId: 'o-1' })
-    })
-
-    expect(handlerRan).toBe(true)
-    // The worker continued the producer's trace under a `queue.<name>` span.
-    expect(remoteCarriers).toContainEqual({ traceparent: 'test-traceparent' })
-    expect(spanNames).toContain('queue.orders-process')
-  })
-})

package/src/__tests__/worker-shutdown-telemetry.test.ts

@@ -1,80 +0,0 @@
-import path from 'node:path'
-import fs from 'node:fs'
-import os from 'node:os'
-
-/**
- * Regression: the worker's graceful shutdown used to close the queues
- * and call process.exit() without flushing telemetry. A worker never returns
- * from run(), so the CLI's post-run shutdownTelemetry() is unreachable — the
- * BatchSpanProcessor's buffered tail (~5s of spans/logs) was dropped on every
- * restart/redeploy. The shutdown handler must flush BEFORE exiting.
- */
-
-import {
-  registerTelemetryRuntime,
-  resetTelemetryRuntime,
-  type TelemetryRuntime,
-} from '@open-mercato/shared/lib/telemetry/runtime'
-
-import { runWorker } from '../worker/runner'
-
-const mockCallOrder: string[] = []
-const runtime: TelemetryRuntime = {
-  canUseGlobalTracePropagation: () => false,
-  captureTraceContext: () => ({}),
-  continueTrace: (_carrier, _name, fn) => fn(),
-  recordHttpDuration: () => {},
-  reportError: () => {},
-  shutdown: jest.fn(async () => {
-    mockCallOrder.push('flush')
-  }),
-}
-
-describe('worker shutdown flushes telemetry', () => {
-  let tmpDir: string
-  let cwd: string
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'worker-shutdown-'))
-    cwd = process.cwd()
-    process.chdir(tmpDir)
-    mockCallOrder.length = 0
-    delete process.env.TELEMETRY_BACKEND
-    registerTelemetryRuntime(runtime)
-  })
-
-  afterEach(() => {
-    process.chdir(cwd)
-    resetTelemetryRuntime()
-    fs.rmSync(tmpDir, { recursive: true, force: true })
-  })
-
-  it('SIGTERM flushes telemetry before process.exit', async () => {
-    const exitSpy = jest.spyOn(process, 'exit').mockImplementation(((code?: number) => {
-      mockCallOrder.push(`exit:${code ?? 0}`)
-      return undefined as never
-    }) as never)
-    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
-
-    try {
-      await runWorker({
-        queueName: 'shutdown-flush-test',
-        handler: async () => {},
-        strategy: 'local',
-        background: true,
-        gracefulShutdown: true,
-      })
-
-      process.emit('SIGTERM')
-      // The shutdown handler is async (close → flush → exit); let it settle.
-      await new Promise((resolve) => setTimeout(resolve, 100))
-
-      expect(mockCallOrder).toContain('flush')
-      expect(mockCallOrder).toContain('exit:0')
-      expect(mockCallOrder.indexOf('flush')).toBeLessThan(mockCallOrder.indexOf('exit:0'))
-    } finally {
-      exitSpy.mockRestore()
-      logSpy.mockRestore()
-    }
-  })
-})

package/src/tracing.ts

@@ -1,58 +0,0 @@
-import { getTelemetryRuntime } from '@open-mercato/shared/lib/telemetry/runtime'
-
-/**
- * Distributed-trace propagation across the enqueue → worker boundary.
- *
- * The W3C trace carrier rides on the job's `metadata._trace` (a first-class
- * metadata channel, not the user payload). Both halves are automatic — the
- * strategies call `attachTraceMetadata` at enqueue and `runJobInTrace` at
- * dispatch — so a worker joins the enqueuing request's trace with no per-worker
- * code. Everything here is a cheap no-op when telemetry is off.
- *
- * This also covers anything that rides the queue: persistent event subscribers
- * (the event bus enqueues) and outbound webhook delivery (queued) become part of
- * the originating request's trace for free.
- */
-const TRACE_META_KEY = '_trace'
-
-/**
- * Attach the active trace context to a job's metadata. Returns `metadata`
- * unchanged when telemetry is off (no active span → empty carrier), so jobs stay
- * clean unless tracing is active.
- */
-export function attachTraceMetadata(
-  metadata: Record<string, unknown> | undefined,
-): Record<string, unknown> | undefined {
-  const carrier = getTelemetryRuntime()?.captureTraceContext() ?? {}
-  if (Object.keys(carrier).length === 0) return metadata
-  return { ...(metadata ?? {}), [TRACE_META_KEY]: carrier }
-}
-
-/**
- * Run a job handler inside a span (`queue.<queueName>`) that continues the
- * producer's trace from the carrier on `metadata`. With no carrier (or telemetry
- * off) it runs `fn` under a fresh root span — and a no-op when off. The span
- * ends when `fn` settles (sync or async).
- */
-export function runJobInTrace<T>(
-  queueName: string,
-  metadata: Record<string, unknown> | undefined,
-  fn: () => T,
-): T {
-  const runtime = getTelemetryRuntime()
-  if (!runtime) return fn()
-  return runtime.continueTrace(
-    readTraceCarrier(metadata),
-    `queue.${queueName}`,
-    fn,
-    { kind: 'consumer' },
-  )
-}
-
-function readTraceCarrier(
-  metadata: Record<string, unknown> | undefined,
-): Record<string, string> | undefined {
-  const raw = metadata?.[TRACE_META_KEY]
-  if (!raw || typeof raw !== 'object') return undefined
-  return raw as Record<string, string>
-}