@voltro/plugin-queue 0.84.0 → 0.86.0

package/dist/cdcSink.js

@@ -0,0 +1,23 @@
+import { activeQueueProvider as e } from "./index.js";
+//#region src/cdcSink.ts
+var t = (t) => {
+	let n = () => t.provider ?? e();
+	return {
+		name: `kafka(${t.topic})`,
+		...t.provider !== void 0 && t.provider.hosts[0] !== void 0 ? { outboundHost: t.provider.hosts[0] } : {},
+		deliver: async (e) => {
+			await n().produce(t.topic, e.map((e) => ({
+				key: e.key,
+				value: JSON.stringify({
+					table: e.table,
+					op: e.op,
+					key: e.key,
+					data: e.data
+				}),
+				headers: { "x-voltro-delivery-key": e.deliveryKey }
+			})));
+		}
+	};
+};
+//#endregion
+export { t as kafkaSink };

package/dist/consumer.js

@@ -0,0 +1,15 @@
+//#region src/consumer.ts
+var e = Symbol.for("@voltro/plugin-queue:consumers"), t = () => {
+	let t = globalThis;
+	return t[e] ??= /* @__PURE__ */ new Map();
+}, n = (e) => {
+	if (e.topic.trim() === "") throw Error("defineQueueConsumer: `topic` must be a non-empty name");
+	if (e.maxAttempts !== void 0 && e.maxAttempts < 1) throw Error(`defineQueueConsumer("${e.topic}"): maxAttempts must be >= 1`);
+	let n = `${e.topic}|${e.groupId ?? ""}`, r = t().get(n);
+	if (r !== void 0 && r !== e) throw Error(`defineQueueConsumer: topic '${e.topic}'${e.groupId ? ` group '${e.groupId}'` : ""} is declared twice — two consumers in one group on one topic would split its partitions unpredictably. Use a distinct groupId for an independent consumer.`);
+	return t().set(n, e), e;
+}, r = () => [...t().values()], i = () => {
+	t().clear();
+};
+//#endregion
+export { n as defineQueueConsumer, r as registeredQueueConsumers, i as resetQueueConsumersForTest };

package/dist/index.d.ts

@@ -114,7 +114,7 @@ export declare interface QueueConsumerDefinition<A = unknown> {
      *  to parse or decode goes STRAIGHT to the dead-letter topic with the
      *  reason — never into the retry loop (a decode failure is deterministic;
      *  retrying it is an infinite loop with extra steps). */
-    readonly schema: Schema.Schema<A, any, never>;
+    readonly schema: Schema.Codec<A, any, never, never>;
     /**
      * The handler. Runs SERIALLY PER PARTITION; its offset commits only after
      * it resolves. It MUST be idempotent: delivery is at-least-once, and a
@@ -247,7 +247,7 @@ export declare interface QueueRunnerLogger {
 export declare class QueueService extends QueueService_base {
 }
 
-declare const QueueService_base: Context.TagClass<QueueService, "@voltro/plugin-queue/QueueService", QueueServiceApi>;
+declare const QueueService_base: Context.ServiceClass<QueueService, "@voltro/plugin-queue/QueueService", QueueServiceApi>;
 
 export declare interface QueueServiceApi {
     /** Produce a batch to a topic (one transport round-trip). NOT transactional

package/dist/index.js

@@ -1,335 +1,70 @@
-import { Cause as e, Context as t, Effect as n, Exit as r, Layer as i, Metric as a, Schema as o } from "effect";
-import { definePlugin as s } from "@voltro/protocol";
-import { Kafka as c, logLevel as l } from "kafkajs";
-import { externalSpanFromTraceparent as u, withServerTracer as d } from "@voltro/runtime";
-//#region src/consumer.ts
-var f = Symbol.for("@voltro/plugin-queue:consumers"), p = () => {
+import { defineQueueConsumer as e, registeredQueueConsumers as t, resetQueueConsumersForTest as n } from "./consumer.js";
+import { queueMetrics as r, recordQueueProduced as i } from "./queueMetrics.js";
+import { kafkaProvider as a } from "./kafka.js";
+import { startQueueConsumers as o } from "./runner.js";
+import { kafkaSink as s } from "./cdcSink.js";
+import { Context as c, Effect as l, Layer as u } from "effect";
+import { definePlugin as d } from "@voltro/protocol";
+//#region src/index.ts
+var f = class extends c.Service()("@voltro/plugin-queue/QueueService") {}, p = Symbol.for("@voltro/plugin-queue:active-provider"), m = () => {
 	let e = globalThis;
-	return e[f] ??= /* @__PURE__ */ new Map();
-}, m = (e) => {
-	if (e.topic.trim() === "") throw Error("defineQueueConsumer: `topic` must be a non-empty name");
-	if (e.maxAttempts !== void 0 && e.maxAttempts < 1) throw Error(`defineQueueConsumer("${e.topic}"): maxAttempts must be >= 1`);
-	let t = `${e.topic}|${e.groupId ?? ""}`, n = p().get(t);
-	if (n !== void 0 && n !== e) throw Error(`defineQueueConsumer: topic '${e.topic}'${e.groupId ? ` group '${e.groupId}'` : ""} is declared twice — two consumers in one group on one topic would split its partitions unpredictably. Use a distinct groupId for an independent consumer.`);
-	return p().set(t, e), e;
-}, h = () => [...p().values()], g = () => {
-	p().clear();
-}, _ = () => Object.create(null), v = Symbol.for("@voltro/plugin-queue:metrics"), y = () => {
-	let e = globalThis;
-	return e[v] ??= {
-		consumed: _(),
-		dlq: _(),
-		retried: _(),
-		lastError: _(),
-		produced: _()
-	};
-}, b = (e, t, n = 1) => {
-	e[t] = (e[t] ?? 0) + n;
-}, x = a.counter("voltro_queue_consumed_total", { description: "Messages a consumer finished with, by topic and outcome (ok | dead-lettered)." }), S = a.counter("voltro_queue_retries_total", { description: "In-process handler retries, by topic. A retry BLOCKS its partition." }), C = a.counter("voltro_queue_produced_total", { description: "Messages produced through the outbox bridge and QueueService, by topic." }), w = a.gauge("voltro_queue_lag_messages", { description: "Messages between the offset just picked up and the partition high watermark, by topic and partition. Sampled at pickup; holds its last value for an idle or revoked partition." }), T = [], E = /* @__PURE__ */ new Map(), D = /* @__PURE__ */ new Map(), O = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Map(), A = (e, t, n) => {
-	let r = e.get(t);
-	if (r !== void 0) return r;
-	let i = n();
-	return e.set(t, i), i;
-}, j = (e) => {
-	b(y().consumed, e), A(E, `ok\u0000${e}`, () => a.tagged(a.tagged(x, "topic", e), "outcome", "ok")).unsafeUpdate(1, T);
-}, M = (e, t) => {
-	let n = y();
-	b(n.dlq, e), n.lastError[e] = t.slice(0, 500), A(E, `dlq\u0000${e}`, () => a.tagged(a.tagged(x, "topic", e), "outcome", "dead-lettered")).unsafeUpdate(1, T);
-}, N = (e) => {
-	b(y().retried, e), A(D, e, () => a.tagged(S, "topic", e)).unsafeUpdate(1, T);
-}, P = (e, t) => {
-	t <= 0 || (b(y().produced, e, t), A(O, e, () => a.tagged(C, "topic", e)).unsafeUpdate(t, T));
-}, F = (e, t, n, r) => {
-	let i;
-	try {
-		let e = BigInt(n) - BigInt(r) - 1n;
-		i = e < 0n ? 0 : Number(e);
-	} catch {
-		return;
-	}
-	A(k, `${e}\u0000${t}`, () => a.tagged(a.tagged(w, "topic", e), "partition", String(t))).unsafeUpdate(i, T);
-}, I = (e) => {
-	let t = {};
-	for (let [n, r] of Object.entries(e ?? {})) r != null && (t[n] = Buffer.isBuffer(r) ? r.toString("utf8") : String(r));
-	return t;
-}, L = (e) => {
-	let t = new c({
-		clientId: e.clientId ?? "voltro",
-		brokers: [...e.brokers],
-		logLevel: l.ERROR,
-		...e.ssl === void 0 ? {} : { ssl: e.ssl },
-		...e.sasl === void 0 ? {} : { sasl: e.sasl }
-	}), n = null, r = /* @__PURE__ */ new Set();
-	return {
-		name: "kafka",
-		hosts: e.brokers.map((e) => e.split("/").pop() ?? e),
-		connect: async () => {
-			n === null && (n = t.producer({ allowAutoTopicCreation: !0 }), await n.connect());
-		},
-		disconnect: async () => {
-			let e = n;
-			n = null, await Promise.all([...r].map((e) => e.disconnect().catch(() => {}))), r.clear(), e !== null && await e.disconnect().catch(() => {});
-		},
-		produce: async (e, t) => {
-			if (n === null) throw Error("kafkaProvider: produce before connect()");
-			await n.send({
-				topic: e,
-				messages: t.map((e) => ({
-					...e.key === void 0 ? {} : { key: e.key },
-					value: e.value,
-					...e.headers === void 0 ? {} : { headers: { ...e.headers } }
-				}))
-			});
-		},
-		ensureTopics: async (e) => {
-			let n = t.admin();
-			await n.connect();
-			try {
-				await n.createTopics({
-					topics: e.map((e) => ({
-						topic: e,
-						numPartitions: 1
-					})),
-					waitForLeaders: !0
-				});
-			} finally {
-				await n.disconnect();
-			}
-		},
-		consume: async (n) => {
-			let i = t.consumer({ groupId: n.groupId });
-			return r.add(i), await i.connect(), await i.subscribe({
-				topic: n.topic,
-				fromBeginning: n.fromBeginning ?? !1
-			}), await i.run({
-				eachBatchAutoResolve: !1,
-				partitionsConsumedConcurrently: e.partitionsConsumedConcurrently ?? 3,
-				eachBatch: async ({ batch: e, resolveOffset: t, commitOffsetsIfNecessary: r, heartbeat: i, isRunning: a, isStale: o }) => {
-					for (let s of e.messages) {
-						if (!a() || o()) return;
-						let c = {
-							topic: e.topic,
-							partition: e.partition,
-							offset: s.offset,
-							key: s.key === null ? null : s.key.toString("utf8"),
-							value: s.value === null ? null : s.value.toString("utf8"),
-							headers: I(s.headers),
-							timestamp: s.timestamp
-						};
-						F(e.topic, e.partition, e.highWatermark, s.offset), await n.onMessage(c, {
-							heartbeat: i,
-							isStale: o
-						}), t(s.offset), await r();
-					}
-				}
-			}), { stop: async () => {
-				r.delete(i), await i.disconnect().catch(() => {});
-			} };
-		}
-	};
-}, R = "queue.consume", z = (e, t) => (r) => {
-	let i = u(e.traceparent);
-	return r.pipe(n.tap((e) => t === void 0 ? n.void : n.annotateCurrentSpan(t(e))), n.withSpan(R, {
-		attributes: {
-			"messaging.system": e.system,
-			"messaging.operation": "process",
-			"messaging.destination.name": e.topic,
-			"messaging.consumer.group.name": e.groupId,
-			"messaging.destination.partition.id": e.partition,
-			"messaging.message.offset": e.offset
-		},
-		...i ? { parent: i } : {}
-	}));
-}, B = async (t, i, a) => {
-	let o, s = await n.runPromiseExit(n.tryPromise({
-		try: i,
-		catch: (e) => (o = { value: e }, e)
-	}).pipe(z(t, a), d));
-	if (r.isSuccess(s)) return s.value;
-	throw o === void 0 ? e.squash(s.cause) : o.value;
-}, V = (e) => new Promise((t) => setTimeout(t, e)), H = async (e) => {
-	let { provider: t, log: n } = e, r = { current: !1 }, i = /* @__PURE__ */ new Set(), a = async (r) => {
-		let i = r.groupId ?? `${e.appName}.${r.topic}`, a = r.dlqTopic ?? `${r.topic}.dlq`, s = r.maxAttempts ?? 3, c = o.decodeUnknownEither(r.schema), l = async (e, i, o) => {
-			M(r.topic, `${e}: ${i}`), n.warn("queue: dead-lettered", {
-				topic: r.topic,
-				dlqTopic: a,
-				reason: e,
-				partition: o.partition,
-				offset: o.offset
-			}), await t.produce(a, [{
-				...o.key === null ? {} : { key: o.key },
-				value: o.value ?? "",
-				headers: {
-					...o.headers,
-					"x-voltro-dlq-reason": e,
-					"x-voltro-dlq-detail": i.slice(0, 500),
-					"x-voltro-dlq-source-topic": o.topic,
-					"x-voltro-dlq-source-partition": String(o.partition),
-					"x-voltro-dlq-source-offset": o.offset
-				}
-			}]);
-		}, u = await t.consume({
-			topic: r.topic,
-			groupId: i,
-			...r.fromBeginning === void 0 ? {} : { fromBeginning: r.fromBeginning },
-			onMessage: async (a, o) => {
-				await B({
-					system: t.name,
-					topic: r.topic,
-					groupId: i,
-					partition: a.partition,
-					offset: a.offset,
-					traceparent: a.headers.traceparent
-				}, async () => {
-					let t;
-					try {
-						t = a.value === null ? null : JSON.parse(a.value);
-					} catch (e) {
-						return await l("decode-failed", `invalid JSON: ${e instanceof Error ? e.message : String(e)}`, a), "dead-lettered";
-					}
-					let i = c(t);
-					if (i._tag === "Left") return await l("decode-failed", String(i.left), a), "dead-lettered";
-					for (let t = 1; t <= s; t++) {
-						if (o.isStale()) return "stale";
-						try {
-							return await r.handler(i.right, {
-								topic: a.topic,
-								partition: a.partition,
-								offset: a.offset,
-								key: a.key,
-								headers: a.headers,
-								attempt: t,
-								...a.headers.traceparent === void 0 ? {} : { traceparent: a.headers.traceparent },
-								get store() {
-									let t = e.store();
-									if (t === null) throw Error("queue: store not bound yet — the retry loop absorbs a message arriving before boot finished");
-									return t;
-								}
-							}), j(r.topic), "ok";
-						} catch (i) {
-							let c = i instanceof Error ? i.message : String(i);
-							if (t >= s) return await l("handler-failed", c, a), "dead-lettered";
-							N(r.topic), n.warn("queue: handler failed, retrying", {
-								topic: r.topic,
-								attempt: t,
-								maxAttempts: s,
-								detail: c
-							}), await o.heartbeat().catch(() => {}), await V((e.retryBaseMs ?? 1e3) * 2 ** (t - 1));
-						}
-					}
-					return "stale";
-				}, (e) => ({ "voltro.queue.outcome": e }));
-			}
-		});
-		return n.info("queue: consumer started", {
-			topic: r.topic,
-			groupId: i,
-			dlqTopic: a
-		}), u;
-	}, s = e.consumers.map((e) => {
-		let t = { handle: null }, o = () => {
-			a(e).then((e) => {
-				if (r.current) {
-					e.stop();
-					return;
-				}
-				t.handle = e;
-			}).catch((t) => {
-				if (r.current) return;
-				n.warn("queue: consumer start failed — retrying in 5s", {
-					topic: e.topic,
-					detail: t instanceof Error ? t.message : String(t)
-				});
-				let a = setTimeout(() => {
-					i.delete(a), o();
-				}, 5e3);
-				i.add(a);
-			});
-		};
-		return o(), t;
-	});
-	return { stop: async () => {
-		r.current = !0;
-		for (let e of i) clearTimeout(e);
-		i.clear(), await Promise.all(s.map((e) => e.handle?.stop() ?? Promise.resolve()));
-	} };
-}, U = (e) => {
-	let t = () => e.provider ?? q();
-	return {
-		name: `kafka(${e.topic})`,
-		...e.provider !== void 0 && e.provider.hosts[0] !== void 0 ? { outboundHost: e.provider.hosts[0] } : {},
-		deliver: async (n) => {
-			await t().produce(e.topic, n.map((e) => ({
-				key: e.key,
-				value: JSON.stringify({
-					table: e.table,
-					op: e.op,
-					key: e.key,
-					data: e.data
-				}),
-				headers: { "x-voltro-delivery-key": e.deliveryKey }
-			})));
-		}
-	};
-}, W = class extends t.Tag("@voltro/plugin-queue/QueueService")() {}, G = Symbol.for("@voltro/plugin-queue:active-provider"), K = () => {
-	let e = globalThis;
-	return e[G] ??= { current: null };
-}, q = () => {
-	let e = K().current;
+	return e[p] ??= { current: null };
+}, h = () => {
+	let e = m().current;
 	if (e === null) throw Error("[voltro] no active queue provider — is queuePlugin({...}) in this app's plugins? The outbox handler and kafkaSink need the plugin's connected provider.");
 	return e;
-}, J = () => ({
+}, g = () => ({
 	effect: "queue.produce",
 	maxAttempts: 8,
 	handler: async ({ payload: e }) => {
 		let t = e.topic, n = e.messages;
 		if (typeof t != "string" || !Array.isArray(n)) throw Error("queue.produce payload must be { topic: string, messages: QueueOutgoingMessage[] }");
-		await q().produce(t, n), P(t, n.length);
+		await h().produce(t, n), i(t, n.length);
 	}
-}), Y = (e) => {
-	let t = e.name ?? "queue", r = L(e), a = ["inspect:read", ...r.hosts.map((e) => `network:outbound:${e}`)], o = null, c = { current: null };
-	return s({
-		name: t,
+}), _ = (e) => {
+	let n = e.name ?? "queue", s = a(e), c = ["inspect:read", ...s.hosts.map((e) => `network:outbound:${e}`)], p = null, h = { current: null };
+	return d({
+		name: n,
 		baseName: "queue",
 		description: "Queue interop — consume and produce against an existing Kafka: Schema-decoded consumers (at-least-once, serial per partition, retry + dead-letter), batched producing via a handler service or transactionally through the outbox, and a kafkaSink for plugin-cdc-out.",
-		permissions: a,
-		services: i.succeed(W, { produce: async (e, t) => {
-			await r.produce(e, t), P(e, t.length);
+		permissions: c,
+		services: u.succeed(f, { produce: async (e, t) => {
+			await s.produce(e, t), i(e, t.length);
 		} }),
 		bindDataStore: (e) => {
-			c.current = e;
+			h.current = e;
 		},
-		onActivate: (t) => n.tryPromise(async () => {
-			await r.connect(), K().current = r;
-			let n = h();
-			o = await H({
-				provider: r,
-				consumers: n,
-				appName: e.groupPrefix ?? t.app.name,
-				log: t.logger,
-				store: () => c.current,
+		onActivate: (n) => l.tryPromise(async () => {
+			await s.connect(), m().current = s;
+			let r = t();
+			p = await o({
+				provider: s,
+				consumers: r,
+				appName: e.groupPrefix ?? n.app.name,
+				log: n.logger,
+				store: () => h.current,
 				...e.retryBaseMs === void 0 ? {} : { retryBaseMs: e.retryBaseMs }
-			}), t.logger.info("queue: connected", {
-				brokers: r.hosts,
-				consumers: n.length
+			}), n.logger.info("queue: connected", {
+				brokers: s.hosts,
+				consumers: r.length
 			});
 		}),
-		onDeactivate: () => n.tryPromise(async () => {
-			await o?.stop(), o = null, K().current === r && (K().current = null), await r.disconnect();
+		onDeactivate: () => l.tryPromise(async () => {
+			await p?.stop(), p = null, m().current === s && (m().current = null), await s.disconnect();
 		}),
 		inspectEndpoints: [{
 			method: "GET",
 			path: "/consumers",
 			scope: "process",
 			description: "Registered consumers + per-topic consumed/retried/dead-lettered/produced counters (this replica).",
-			handler: () => n.sync(() => {
-				let e = y();
+			handler: () => l.sync(() => {
+				let e = r();
 				return {
 					kind: "json",
 					data: {
-						producerSelected: K().current === r,
-						brokers: r.hosts,
-						consumers: h().map((t) => ({
+						producerSelected: m().current === s,
+						brokers: s.hosts,
+						consumers: t().map((t) => ({
 							topic: t.topic,
 							groupId: t.groupId ?? null,
 							dlqTopic: t.dlqTopic ?? `${t.topic}.dlq`,
@@ -347,4 +82,4 @@ var f = Symbol.for("@voltro/plugin-queue:consumers"), p = () => {
 	});
 };
 //#endregion
-export { W as QueueService, q as activeQueueProvider, m as defineQueueConsumer, L as kafkaProvider, U as kafkaSink, y as queueMetrics, J as queueOutboxHandler, Y as queuePlugin, h as registeredQueueConsumers, g as resetQueueConsumersForTest, H as startQueueConsumers };
+export { f as QueueService, h as activeQueueProvider, e as defineQueueConsumer, a as kafkaProvider, s as kafkaSink, r as queueMetrics, g as queueOutboxHandler, _ as queuePlugin, t as registeredQueueConsumers, n as resetQueueConsumersForTest, o as startQueueConsumers };

package/dist/kafka.js

@@ -0,0 +1,85 @@
+import { recordQueueLag as e } from "./queueMetrics.js";
+import { Kafka as t, logLevel as n } from "kafkajs";
+//#region src/kafka.ts
+var r = (e) => {
+	let t = {};
+	for (let [n, r] of Object.entries(e ?? {})) r != null && (t[n] = Buffer.isBuffer(r) ? r.toString("utf8") : String(r));
+	return t;
+}, i = (i) => {
+	let a = new t({
+		clientId: i.clientId ?? "voltro",
+		brokers: [...i.brokers],
+		logLevel: n.ERROR,
+		...i.ssl === void 0 ? {} : { ssl: i.ssl },
+		...i.sasl === void 0 ? {} : { sasl: i.sasl }
+	}), o = null, s = /* @__PURE__ */ new Set();
+	return {
+		name: "kafka",
+		hosts: i.brokers.map((e) => e.split("/").pop() ?? e),
+		connect: async () => {
+			o === null && (o = a.producer({ allowAutoTopicCreation: !0 }), await o.connect());
+		},
+		disconnect: async () => {
+			let e = o;
+			o = null, await Promise.all([...s].map((e) => e.disconnect().catch(() => {}))), s.clear(), e !== null && await e.disconnect().catch(() => {});
+		},
+		produce: async (e, t) => {
+			if (o === null) throw Error("kafkaProvider: produce before connect()");
+			await o.send({
+				topic: e,
+				messages: t.map((e) => ({
+					...e.key === void 0 ? {} : { key: e.key },
+					value: e.value,
+					...e.headers === void 0 ? {} : { headers: { ...e.headers } }
+				}))
+			});
+		},
+		ensureTopics: async (e) => {
+			let t = a.admin();
+			await t.connect();
+			try {
+				await t.createTopics({
+					topics: e.map((e) => ({
+						topic: e,
+						numPartitions: 1
+					})),
+					waitForLeaders: !0
+				});
+			} finally {
+				await t.disconnect();
+			}
+		},
+		consume: async (t) => {
+			let n = a.consumer({ groupId: t.groupId });
+			return s.add(n), await n.connect(), await n.subscribe({
+				topic: t.topic,
+				fromBeginning: t.fromBeginning ?? !1
+			}), await n.run({
+				eachBatchAutoResolve: !1,
+				partitionsConsumedConcurrently: i.partitionsConsumedConcurrently ?? 3,
+				eachBatch: async ({ batch: n, resolveOffset: i, commitOffsetsIfNecessary: a, heartbeat: o, isRunning: s, isStale: c }) => {
+					for (let l of n.messages) {
+						if (!s() || c()) return;
+						let u = {
+							topic: n.topic,
+							partition: n.partition,
+							offset: l.offset,
+							key: l.key === null ? null : l.key.toString("utf8"),
+							value: l.value === null ? null : l.value.toString("utf8"),
+							headers: r(l.headers),
+							timestamp: l.timestamp
+						};
+						e(n.topic, n.partition, n.highWatermark, l.offset), await t.onMessage(u, {
+							heartbeat: o,
+							isStale: c
+						}), i(l.offset), await a();
+					}
+				}
+			}), { stop: async () => {
+				s.delete(n), await n.disconnect().catch(() => {});
+			} };
+		}
+	};
+};
+//#endregion
+export { i as kafkaProvider };

package/dist/queueMetrics.js

@@ -0,0 +1,39 @@
+import { Context as e, Metric as t } from "effect";
+//#region src/queueMetrics.ts
+var n = () => Object.create(null), r = Symbol.for("@voltro/plugin-queue:metrics"), i = () => {
+	let e = globalThis;
+	return e[r] ??= {
+		consumed: n(),
+		dlq: n(),
+		retried: n(),
+		lastError: n(),
+		produced: n()
+	};
+}, a = (e, t, n = 1) => {
+	e[t] = (e[t] ?? 0) + n;
+}, o = t.counter("voltro_queue_consumed_total", { description: "Messages a consumer finished with, by topic and outcome (ok | dead-lettered)." }), s = t.counter("voltro_queue_retries_total", { description: "In-process handler retries, by topic. A retry BLOCKS its partition." }), c = t.counter("voltro_queue_produced_total", { description: "Messages produced through the outbox bridge and QueueService, by topic." }), l = t.gauge("voltro_queue_lag_messages", { description: "Messages between the offset just picked up and the partition high watermark, by topic and partition. Sampled at pickup; holds its last value for an idle or revoked partition." }), u = e.empty(), d = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map(), h = (e, t, n) => {
+	let r = e.get(t);
+	if (r !== void 0) return r;
+	let i = n();
+	return e.set(t, i), i;
+}, g = (e) => {
+	a(i().consumed, e), h(d, `ok\u0000${e}`, () => t.withAttributes(t.withAttributes(o, { topic: e }), { outcome: "ok" })).updateUnsafe(1, u);
+}, _ = (e, n) => {
+	let r = i();
+	a(r.dlq, e), r.lastError[e] = n.slice(0, 500), h(d, `dlq\u0000${e}`, () => t.withAttributes(t.withAttributes(o, { topic: e }), { outcome: "dead-lettered" })).updateUnsafe(1, u);
+}, v = (e) => {
+	a(i().retried, e), h(f, e, () => t.withAttributes(s, { topic: e })).updateUnsafe(1, u);
+}, y = (e, n) => {
+	n <= 0 || (a(i().produced, e, n), h(p, e, () => t.withAttributes(c, { topic: e })).updateUnsafe(n, u));
+}, b = (e, n, r, i) => {
+	let a;
+	try {
+		let e = BigInt(r) - BigInt(i) - 1n;
+		a = e < 0n ? 0 : Number(e);
+	} catch {
+		return;
+	}
+	h(m, `${e}\u0000${n}`, () => t.withAttributes(t.withAttributes(l, { topic: e }), { partition: String(n) })).updateUnsafe(a, u);
+};
+//#endregion
+export { i as queueMetrics, g as recordQueueConsumed, _ as recordQueueDeadLettered, b as recordQueueLag, y as recordQueueProduced, v as recordQueueRetry };

package/dist/queueTracing.js

@@ -0,0 +1,26 @@
+import { Cause as e, Effect as t, Exit as n } from "effect";
+import { externalSpanFromTraceparent as r, withServerTracer as i } from "@voltro/runtime";
+//#region src/queueTracing.ts
+var a = "queue.consume", o = (e, n) => (i) => {
+	let o = r(e.traceparent);
+	return i.pipe(t.tap((e) => n === void 0 ? t.void : t.annotateCurrentSpan(n(e))), t.withSpan(a, {
+		attributes: {
+			"messaging.system": e.system,
+			"messaging.operation": "process",
+			"messaging.destination.name": e.topic,
+			"messaging.consumer.group.name": e.groupId,
+			"messaging.destination.partition.id": e.partition,
+			"messaging.message.offset": e.offset
+		},
+		...o ? { parent: o } : {}
+	}));
+}, s = async (r, a, s) => {
+	let c, l = await t.runPromiseExit(t.tryPromise({
+		try: a,
+		catch: (e) => (c = { value: e }, e)
+	}).pipe(o(r, s), i));
+	if (n.isSuccess(l)) return l.value;
+	throw c === void 0 ? e.squash(l.cause) : c.value;
+};
+//#endregion
+export { a as QUEUE_CONSUME_SPAN, s as runInQueueMessageSpan, o as withQueueMessageSpan };