@shivaedev/effect-pg-boss 0.5.0 → 0.6.1

package/src/server/internal/tracing.ts

@@ -0,0 +1,44 @@
+import { Effect, Option, Schema, Tracer } from "effect";
+import type { Job } from "pg-boss";
+
+const TracedPayload = Schema.Struct({
+	_tag: Schema.Literal("@shivaedev/effect-pg-boss/TracedPayload"),
+	payload: Schema.Unknown,
+	span: Schema.Struct({ sampled: Schema.Boolean, spanId: Schema.String, traceId: Schema.String }),
+});
+
+const isTracedPayload = Schema.is(TracedPayload);
+
+export function capturePayload(payload: object): Effect.Effect<object> {
+	return Effect.map(Effect.option(Effect.currentParentSpan), (span) =>
+		Option.isNone(span)
+			? payload
+			: ({
+					_tag: "@shivaedev/effect-pg-boss/TracedPayload",
+					payload,
+					span: { sampled: span.value.sampled, spanId: span.value.spanId, traceId: span.value.traceId },
+				} satisfies typeof TracedPayload.Type),
+	);
+}
+
+export function payloadOf(data: unknown): unknown {
+	return isTracedPayload(data) ? data.payload : data;
+}
+
+export function traceJob<A, E, R>(effect: Effect.Effect<A, E, R>, job: Job<unknown>, queue: string) {
+	return Effect.withSpan(effect, queue, {
+		attributes: {
+			"job.attempt": job.retryCount + 1,
+			"job.id": job.id,
+			"job.name": job.name,
+			"job.queue": queue,
+			"job.retry_count": job.retryCount,
+			"messaging.destination.name": queue,
+			"messaging.message.id": job.id,
+			"messaging.system": "pg-boss",
+		},
+		kind: "consumer",
+		links: isTracedPayload(job.data) ? [{ attributes: {}, span: Tracer.externalSpan(job.data.span) }] : [],
+		root: true,
+	});
+}

package/src/server/service.ts

@@ -1,20 +1,26 @@
 import { Context, Effect, Layer, type Option, type Schema } from "effect";
-import type { ConstructorOptions, SendOptions, StopOptions } from "pg-boss";
+import type { ConstructorOptions, JobWithMetadata, SendOptions, StopOptions } from "pg-boss";
 import type { PgBossClientFactory } from "#client.ts";
+import type { JobPayloadSchema, JobRegistration, QueueDefinition, RegistrationRequirements } from "#definition.ts";
+import type { PgBossError, PgBossPayloadError, PgBossQueueOptionsError } from "#error.ts";
+import type { JobsHealth, QueueCounts } from "#health.ts";
 import { acquireClient, releaseClient } from "#internal/lifecycle.ts";
 import { registerJobs, registrationName } from "#internal/register.ts";
 import { makeService } from "#internal/service.ts";
-import type { JobPayloadSchema, JobRegistration, QueueDefinition, RegistrationRequirements } from "./definition.ts";
-import type { PgBossError, PgBossPayloadError } from "./error.ts";
-import type { JobsHealth } from "./health.ts";
 
 export interface PgBossService {
+	readonly counts: (queue: QueueDefinition) => Effect.Effect<QueueCounts, PgBossError>;
 	readonly enqueue: <const TName extends string, const TPayload extends JobPayloadSchema>(
 		queue: QueueDefinition<TName, TPayload>,
 		payload: Schema.Schema.Type<TPayload>,
 		options?: SendOptions,
 	) => Effect.Effect<Option.Option<string>, PgBossError | PgBossPayloadError, TPayload["EncodingServices"]>;
+	readonly getJob: <const TName extends string, const TPayload extends JobPayloadSchema>(
+		queue: QueueDefinition<TName, TPayload>,
+		id: string,
+	) => Effect.Effect<Option.Option<JobWithMetadata<TPayload["Type"]>>, PgBossError | PgBossPayloadError, TPayload["DecodingServices"]>;
 	readonly health: Effect.Effect<JobsHealth, PgBossError>;
+	readonly retry: (queue: QueueDefinition, id: string) => Effect.Effect<void, PgBossError>;
 }
 
 export type PgBossLayerOptions<TRegistrations extends readonly JobRegistration[], TErrorRequirements> = ConstructorOptions & {
@@ -29,7 +35,7 @@ export type PgBossLayerOptions<TRegistrations extends readonly JobRegistration[]
 export interface PgBossDefinition<TIdentifier extends string = string> extends Context.Service<TIdentifier, PgBossService> {
 	readonly layer: <const TRegistrations extends readonly JobRegistration[], TErrorRequirements = never>(
 		options: PgBossLayerOptions<TRegistrations, TErrorRequirements>,
-	) => Layer.Layer<TIdentifier, PgBossError, RegistrationRequirements<TRegistrations> | TErrorRequirements>;
+	) => Layer.Layer<TIdentifier, PgBossError | PgBossQueueOptionsError, RegistrationRequirements<TRegistrations> | TErrorRequirements>;
 }
 
 function logClientError(error: Error): Effect.Effect<void> {
@@ -41,7 +47,7 @@ export const makePgBoss = <const TIdentifier extends string>(identifier: TIdenti
 
 	const layer = <const TRegistrations extends readonly JobRegistration[], TErrorRequirements = never>(
 		options: PgBossLayerOptions<TRegistrations, TErrorRequirements>,
-	): Layer.Layer<TIdentifier, PgBossError, RegistrationRequirements<TRegistrations> | TErrorRequirements> => {
+	): Layer.Layer<TIdentifier, PgBossError | PgBossQueueOptionsError, RegistrationRequirements<TRegistrations> | TErrorRequirements> => {
 		type Requirements = RegistrationRequirements<TRegistrations> | TErrorRequirements;
 		const names = options.jobs.map(registrationName);
 		const { clientFactory, clientCacheKey, jobs, onError, stop, ...constructorOptions } = options;
@@ -76,7 +82,7 @@ export const makePgBoss = <const TIdentifier extends string>(identifier: TIdenti
 
 		return Layer.effect(
 			Service,
-			Effect.map(acquire, ({ acquired }) => makeService(acquired.client, names)),
+			Effect.map(acquire, ({ acquired }) => makeService(acquired.client, names, constructorOptions.schema)),
 		);
 	};