@pikku/queue-nats 0.12.3 → 0.12.5

package/dist/index.d.ts

@@ -32,6 +32,6 @@ export { NatsSchedulerService, toNatsCron, parseNatsSchedule, } from './nats-sch
 export { NatsQueueWorkers, mapPikkuWorkerToNats } from './nats-queue-worker.js';
 export { consumeQueue } from './consume.js';
 export type { ConsumeHandle, ConsumeOptions } from './consume.js';
-export { consumerNameForQueue, queueNameToToken, subjectForQueue, backoffDelayMs, attemptsFor, backoffFor, scheduleSubjectFor, PIKKU_USER_ID_HEADER, NATS_MSG_ID_HEADER, ATTEMPTS_HEADER, BACKOFF_TYPE_HEADER, BACKOFF_DELAY_HEADER, SCHEDULE_HEADER, SCHEDULE_TARGET_HEADER, SCHEDULE_TIMEZONE_HEADER, SCHEDULE_NEXT_HEADER, SCHEDULER_HEADER, SCHEDULE_SUBJECT_SEGMENT, } from './utils.js';
+export { consumerNameForQueue, queueNameToToken, subjectForQueue, backoffDelayMs, attemptsFor, backoffFor, scheduleSubjectFor, PIKKU_USER_ID_HEADER, TRACEPARENT_HEADER, NATS_MSG_ID_HEADER, ATTEMPTS_HEADER, BACKOFF_TYPE_HEADER, BACKOFF_DELAY_HEADER, SCHEDULE_HEADER, SCHEDULE_TARGET_HEADER, SCHEDULE_TIMEZONE_HEADER, SCHEDULE_NEXT_HEADER, SCHEDULER_HEADER, SCHEDULE_SUBJECT_SEGMENT, } from './utils.js';
 export { headers as natsHeaders } from '@nats-io/nats-core';
 export type { QueueService, PikkuWorkerConfig, PikkuJobConfig, QueueJob, JobOptions, } from '@pikku/core/queue';

package/dist/index.js

@@ -35,7 +35,7 @@ export { NatsQueueWorkers, mapPikkuWorkerToNats } from './nats-queue-worker.js';
 // registry — e.g. a dispatcher whose queues are shared across tenants and must
 // not collide with the registry's global queue names.
 export { consumeQueue } from './consume.js';
-export { consumerNameForQueue, queueNameToToken, subjectForQueue, backoffDelayMs, attemptsFor, backoffFor, scheduleSubjectFor, PIKKU_USER_ID_HEADER, NATS_MSG_ID_HEADER, ATTEMPTS_HEADER, BACKOFF_TYPE_HEADER, BACKOFF_DELAY_HEADER, SCHEDULE_HEADER, SCHEDULE_TARGET_HEADER, SCHEDULE_TIMEZONE_HEADER, SCHEDULE_NEXT_HEADER, SCHEDULER_HEADER, SCHEDULE_SUBJECT_SEGMENT, } from './utils.js';
+export { consumerNameForQueue, queueNameToToken, subjectForQueue, backoffDelayMs, attemptsFor, backoffFor, scheduleSubjectFor, PIKKU_USER_ID_HEADER, TRACEPARENT_HEADER, NATS_MSG_ID_HEADER, ATTEMPTS_HEADER, BACKOFF_TYPE_HEADER, BACKOFF_DELAY_HEADER, SCHEDULE_HEADER, SCHEDULE_TARGET_HEADER, SCHEDULE_TIMEZONE_HEADER, SCHEDULE_NEXT_HEADER, SCHEDULER_HEADER, SCHEDULE_SUBJECT_SEGMENT, } from './utils.js';
 // Re-exported so callers that publish their own messages (a dispatcher parking
 // a job on a DLQ, say) can build headers without taking a direct dependency on
 // nats-core — this package is the NATS boundary.

package/dist/nats-delayed-publisher.js

@@ -1,5 +1,5 @@
 import { headers } from '@nats-io/nats-core';
-import { ATTEMPTS_HEADER, BACKOFF_DELAY_HEADER, BACKOFF_TYPE_HEADER, PIKKU_USER_ID_HEADER, SCHEDULE_HEADER, SCHEDULE_TARGET_HEADER, attemptsHeaderValue, scheduleSubjectFor, subjectForQueue, } from './utils.js';
+import { ATTEMPTS_HEADER, BACKOFF_DELAY_HEADER, BACKOFF_TYPE_HEADER, PIKKU_USER_ID_HEADER, TRACEPARENT_HEADER, SCHEDULE_HEADER, SCHEDULE_TARGET_HEADER, attemptsHeaderValue, scheduleSubjectFor, subjectForQueue, } from './utils.js';
 /**
  * Delayed delivery using JetStream's own message scheduler (server 2.12+).
  *
@@ -70,6 +70,9 @@ const applyJobHeaders = (hdrs, options, queueName) => {
     if (options.pikkuUserId) {
         hdrs.set(PIKKU_USER_ID_HEADER, options.pikkuUserId);
     }
+    if (options.traceparent) {
+        hdrs.set(TRACEPARENT_HEADER, options.traceparent);
+    }
     if (options.attempts !== undefined) {
         hdrs.set(ATTEMPTS_HEADER, attemptsHeaderValue(options.attempts, queueName));
     }

package/dist/nats-queue-service.js

@@ -1,5 +1,5 @@
 import { headers } from '@nats-io/nats-core';
-import { ATTEMPTS_HEADER, BACKOFF_DELAY_HEADER, BACKOFF_TYPE_HEADER, NATS_MSG_ID_HEADER, PIKKU_USER_ID_HEADER, attemptsHeaderValue, subjectForQueue, } from './utils.js';
+import { ATTEMPTS_HEADER, BACKOFF_DELAY_HEADER, BACKOFF_TYPE_HEADER, NATS_MSG_ID_HEADER, PIKKU_USER_ID_HEADER, TRACEPARENT_HEADER, attemptsHeaderValue, subjectForQueue, } from './utils.js';
 /**
  * JetStream queue service for publishing jobs.
  *
@@ -35,6 +35,9 @@ export class NatsQueueService {
         if (options?.pikkuUserId) {
             hdrs.set(PIKKU_USER_ID_HEADER, options.pikkuUserId);
         }
+        if (options?.traceparent) {
+            hdrs.set(TRACEPARENT_HEADER, options.traceparent);
+        }
         // JetStream dedupes on this header within the stream's duplicate window,
         // which is the closest equivalent to pg-boss's singleton `jobId`.
         if (options?.jobId) {

package/dist/nats-queue-worker.js

@@ -1,7 +1,8 @@
 import { AckPolicy, DeliverPolicy } from '@nats-io/jetstream';
 import { QueueJobDiscardedError, QueueJobFailedError, registerQueueWorkers, runQueueJob, } from '@pikku/core/queue';
 import { pikkuState } from '@pikku/core/state';
-import { attemptsFor, backoffFor, mapJsMsgToQueueJob } from './utils.js';
+import { parseTraceparent, tracedLogger } from '@pikku/core/trace';
+import { attemptsFor, backoffFor, mapJsMsgToQueueJob, TRACEPARENT_HEADER, } from './utils.js';
 import { consumeQueue } from './consume.js';
 const MS_TO_NS = 1_000_000;
 /**
@@ -154,14 +155,15 @@ export class NatsQueueWorkers {
             // to mean "never retry"), while max_deliver is per-consumer — and an unset
             // max_deliver means unlimited, so without this a step marked no-retry
             // would be redelivered forever.
+            const failed = tracedLogger(logger, parseTraceparent(msg.headers?.get(TRACEPARENT_HEADER))?.traceId);
             const attempts = attemptsFor(msg);
             if (attempts !== undefined && msg.info.deliveryCount >= attempts) {
-                logger.error(`NATS message ${msg.seq} on ${queueName} failed after ${msg.info.deliveryCount}/${attempts} attempts, giving up: ${message}`);
+                failed.error(`NATS message ${msg.seq} on ${queueName} failed after ${msg.info.deliveryCount}/${attempts} attempts, giving up: ${message}`);
                 msg.term();
                 return;
             }
             const delayMs = backoffFor(msg);
-            logger.error(`NATS message ${msg.seq} on ${queueName} failed (attempt ${msg.info.deliveryCount}${attempts ? `/${attempts}` : ''}), retrying in ${delayMs}ms: ${message}`);
+            failed.error(`NATS message ${msg.seq} on ${queueName} failed (attempt ${msg.info.deliveryCount}${attempts ? `/${attempts}` : ''}), retrying in ${delayMs}ms: ${message}`);
             // nak(delay) is what makes backoff real. A bare nak() redelivers as fast
             // as the server can, which turns an exponential-backoff policy into a hot
             // loop against whatever is already failing.

package/dist/nats-scheduler-service.d.ts

@@ -86,7 +86,7 @@ export declare class NatsSchedulerService extends SchedulerService {
      * *is* the handle. `@at` schedules are purged by the server once they fire,
      * so a fired task simply stops being findable.
      */
-    scheduleRPC(delay: number | string, rpcName: string, data?: any, session?: CoreUserSession): Promise<string>;
+    scheduleRPC(delay: number | string, rpcName: string, data?: any, session?: CoreUserSession, traceparent?: string): Promise<string>;
     /**
      * Cancel a scheduled task. Idempotent — purging a subject that holds no
      * message is not an error, so cancelling a task that already fired returns

package/dist/nats-scheduler-service.js

@@ -5,11 +5,11 @@ import { parseDurationString } from '@pikku/core/utils';
 import { pikkuState } from '@pikku/core/state';
 import { getScheduledTasks, runScheduledTask } from '@pikku/core/scheduler';
 import { consumeQueue } from './consume.js';
-import { SCHEDULE_HEADER, SCHEDULE_TARGET_HEADER, SCHEDULE_TIMEZONE_HEADER, SCHEDULE_SUBJECT_SEGMENT, queueNameToToken, scheduleSubjectFor, subjectForQueue, } from './utils.js';
+import { SCHEDULE_HEADER, SCHEDULE_TARGET_HEADER, SCHEDULE_TIMEZONE_HEADER, SCHEDULE_SUBJECT_SEGMENT, TRACEPARENT_HEADER, queueNameToToken, scheduleSubjectFor, subjectForQueue, } from './utils.js';
 /**
  * Queue recurring cron fires land on.
  *
- * Deliberately separate from `pikku-remote-internal-rpc` (where one-off
+ * Deliberately separate from `pikku-mesh-rpc` (where one-off
  * `scheduleRPC` calls land): that queue is a registered pikku worker whose
  * consumer is owned by the queue registry, and a recurring task is not an RPC
  * invocation — it goes through `runScheduledTask`, which resolves the task's
@@ -18,7 +18,7 @@ import { SCHEDULE_HEADER, SCHEDULE_TARGET_HEADER, SCHEDULE_TIMEZONE_HEADER, SCHE
  */
 const RECURRING_TASK_QUEUE = 'pikku-recurring-scheduled-task';
 /** Queue a one-off `scheduleRPC` fires onto — a registered pikku worker. */
-const REMOTE_RPC_QUEUE = 'pikku-remote-internal-rpc';
+const MESH_RPC_QUEUE = 'pikku-mesh-rpc';
 /** Concurrent in-flight scheduled tasks. */
 const RECURRING_MAX_ACK_PENDING = 5;
 /** Ack window for a recurring fire. Generous: recurring tasks are batch
@@ -123,14 +123,16 @@ export class NatsSchedulerService extends SchedulerService {
      * *is* the handle. `@at` schedules are purged by the server once they fire,
      * so a fired task simply stops being findable.
      */
-    async scheduleRPC(delay, rpcName, data, session) {
+    async scheduleRPC(delay, rpcName, data, session, traceparent) {
         const delayMs = typeof delay === 'string' ? parseDurationString(delay) : delay;
-        const subject = scheduleSubjectFor(this.subjectPrefix, REMOTE_RPC_QUEUE);
+        const subject = scheduleSubjectFor(this.subjectPrefix, MESH_RPC_QUEUE);
         const hdrs = headers();
         // A timestamp already in the past fires immediately rather than erroring,
         // which matches pg-boss's `startAfter` with an elapsed date.
         hdrs.set(SCHEDULE_HEADER, `@at ${new Date(Date.now() + delayMs).toISOString()}`);
-        hdrs.set(SCHEDULE_TARGET_HEADER, subjectForQueue(this.subjectPrefix, REMOTE_RPC_QUEUE));
+        hdrs.set(SCHEDULE_TARGET_HEADER, subjectForQueue(this.subjectPrefix, MESH_RPC_QUEUE));
+        if (traceparent)
+            hdrs.set(TRACEPARENT_HEADER, traceparent);
         await this.js.publish(subject, JSON.stringify({ rpcName, data, session }), { headers: hdrs });
         return subject;
     }

package/dist/utils.d.ts

@@ -2,6 +2,7 @@ import type { JsMsg } from '@nats-io/jetstream';
 import type { QueueJob, QueueJobStatus } from '@pikku/core/queue';
 /** Header carrying the producer's pikku user id through to the worker. */
 export declare const PIKKU_USER_ID_HEADER = "Pikku-User-Id";
+export declare const TRACEPARENT_HEADER = "traceparent";
 /** Header JetStream itself reads for publish-side dedupe within the stream's window. */
 export declare const NATS_MSG_ID_HEADER = "Nats-Msg-Id";
 /**

package/dist/utils.js

@@ -1,5 +1,6 @@
 /** Header carrying the producer's pikku user id through to the worker. */
 export const PIKKU_USER_ID_HEADER = 'Pikku-User-Id';
+export const TRACEPARENT_HEADER = 'traceparent';
 /** Header JetStream itself reads for publish-side dedupe within the stream's window. */
 export const NATS_MSG_ID_HEADER = 'Nats-Msg-Id';
 /**
@@ -151,4 +152,5 @@ export const mapJsMsgToQueueJob = (queueName, msg) => ({
     data: msg.json(),
     metadata: () => jsMsgMetadata(msg),
     pikkuUserId: msg.headers?.get(PIKKU_USER_ID_HEADER) || undefined,
+    traceparent: msg.headers?.get(TRACEPARENT_HEADER) || undefined,
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/queue-nats",
-  "version": "0.12.3",
+  "version": "0.12.5",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/pikkujs/pikku.git",
@@ -23,7 +23,7 @@
     "clean": "rm -rf dist tsconfig.tsbuildinfo"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.144"
+    "@pikku/core": "^0.12.151"
   },
   "dependencies": {
     "@nats-io/jetstream": "^3.4.0",