@effect-app/infra 4.0.0-beta.120 → 4.0.0-beta.122

package/src/QueueMaker/SQLQueue.ts

@@ -13,7 +13,7 @@ export const QueueId = S.Finite.pipe(S.brand("QueueId"))
 export type QueueId = typeof QueueId.Type
 
 // TODO: let the model track and Auto Generate versionColumn on every update instead
-export function makeSQLQueue<
+export const makeSQLQueue = Effect.fnUntraced(function*<
   Evt extends { id: S.StringId; _tag: string },
   DrainEvt extends { id: S.StringId; _tag: string },
   EvtE,
@@ -24,167 +24,136 @@ export function makeSQLQueue<
   schema: S.Codec<Evt, EvtE>,
   drainSchema: S.Codec<DrainEvt, DrainEvtE>
 ) {
-  return Effect.gen(function*() {
-    const base = {
-      id: SQLModel.Generated(QueueId),
-      meta: SQLModel.JsonFromString(QueueMeta),
-      name: S.NonEmptyString255,
-      createdAt: SQLModel.DateTimeInsert,
-      updatedAt: SQLModel.DateTimeUpdate,
-      // TODO: at+owner
-      processingAt: SQLModel.FieldOption(S.Date),
-      finishedAt: SQLModel.FieldOption(S.Date),
-      etag: S.String // TODO: use a SQLModel thing that auto updates it?
-      // TODO: record locking.. / optimistic locking
-      // rowVersion: SQLModel.DateTimeFromNumberWithNow
-    }
-    class Queue extends SQLModel.Class<Queue>("Queue")({
-      body: SQLModel.JsonFromString(schema),
-      ...base
-    }) {}
-    class Drain extends SQLModel.Class<Drain>("Drain")({
-      body: SQLModel.JsonFromString(drainSchema),
-      ...base
-    }) {}
-    const sql = yield* SqlClient.SqlClient
+  const base = {
+    id: SQLModel.Generated(QueueId),
+    meta: SQLModel.JsonFromString(QueueMeta),
+    name: S.NonEmptyString255,
+    createdAt: SQLModel.DateTimeInsert,
+    updatedAt: SQLModel.DateTimeUpdate,
+    // TODO: at+owner
+    processingAt: SQLModel.FieldOption(S.Date),
+    finishedAt: SQLModel.FieldOption(S.Date),
+    etag: S.String // TODO: use a SQLModel thing that auto updates it?
+    // TODO: record locking.. / optimistic locking
+    // rowVersion: SQLModel.DateTimeFromNumberWithNow
+  }
+  class Queue extends SQLModel.Class<Queue>("Queue")({
+    body: SQLModel.JsonFromString(schema),
+    ...base
+  }) {}
+  class Drain extends SQLModel.Class<Drain>("Drain")({
+    body: SQLModel.JsonFromString(drainSchema),
+    ...base
+  }) {}
+  const sql = yield* SqlClient.SqlClient
 
-    const queueRepo = yield* SQLModel.makeRepository(Queue, {
-      tableName: "queue",
-      spanPrefix: "QueueRepo",
-      idColumn: "id",
-      versionColumn: "etag"
-    })
+  const queueRepo = yield* SQLModel.makeRepository(Queue, {
+    tableName: "queue",
+    spanPrefix: "QueueRepo",
+    idColumn: "id",
+    versionColumn: "etag"
+  })
 
-    const drainRepo = yield* SQLModel.makeRepository(Drain, {
-      tableName: "queue",
-      spanPrefix: "DrainRepo",
-      idColumn: "id",
-      versionColumn: "etag"
-    })
+  const drainRepo = yield* SQLModel.makeRepository(Drain, {
+    tableName: "queue",
+    spanPrefix: "DrainRepo",
+    idColumn: "id",
+    versionColumn: "etag"
+  })
 
-    const decodeDrain = S.decodeEffect(Drain)
+  const decodeDrain = S.decodeEffect(Drain)
 
-    const drain = Effect
-      .sync(() => subMinutes(new Date(), 15))
-      .pipe(
-        Effect
-          .andThen((limit) =>
-            sql<typeof Drain.Encoded>`SELECT *
+  const drain = Effect.gen(function*() {
+    const limit = subMinutes(new Date(), 15)
+    return yield* sql<typeof Drain.Encoded>`SELECT *
     FROM queue
     WHERE name = ${queueDrainName} AND finishedAt IS NULL AND (processingAt IS NULL OR processingAt < ${limit.getTime()})
     LIMIT 1`
-          )
-      )
+  })
 
-    const q = {
-      offer: Effect.fnUntraced(function*(body: Evt, meta: typeof QueueMeta.Type) {
-        yield* queueRepo.insertVoid(Queue.insert.make({
-          body,
-          meta,
-          name: queueName,
-          processingAt: Option.none(),
-          finishedAt: Option.none(),
-          etag: crypto.randomUUID()
-        }))
-      }),
-      take: Effect.gen(function*() {
-        while (true) {
-          const [first] = yield* drain.pipe(Effect.withTracerEnabled(false)) // disable sql tracer otherwise we spam it..
-          if (first) {
-            const dec = yield* decodeDrain(first)
-            const { createdAt, updatedAt, ...rest } = dec
-            return yield* drainRepo.update(
-              Drain.update.make({ ...rest, processingAt: Option.some(new Date()) }) // auto in lib , etag: crypto.randomUUID()
-            )
-          }
-          if (first) return first
-          yield* Effect.sleep(250)
+  const q = {
+    offer: Effect.fnUntraced(function*(body: Evt, meta: typeof QueueMeta.Type) {
+      yield* queueRepo.insertVoid(Queue.insert.make({
+        body,
+        meta,
+        name: queueName,
+        processingAt: Option.none(),
+        finishedAt: Option.none(),
+        etag: crypto.randomUUID()
+      }))
+    }),
+    take: Effect.gen(function*() {
+      while (true) {
+        const [first] = yield* drain.pipe(Effect.withTracerEnabled(false)) // disable sql tracer otherwise we spam it..
+        if (first) {
+          const dec = yield* decodeDrain(first)
+          const { createdAt, updatedAt, ...rest } = dec
+          return yield* drainRepo.update(
+            Drain.update.make({ ...rest, processingAt: Option.some(new Date()) }) // auto in lib , etag: crypto.randomUUID()
+          )
         }
-      }),
-      finish: Effect.fn(function*({ createdAt, updatedAt, ...q }: Drain) {
-        return yield* drainRepo.updateVoid(Drain.update.make({ ...q, finishedAt: Option.some(new Date()) })) // auto in lib , etag: crypto.randomUUID()
-      })
-    }
-    const queue = {
-      publish: (...messages: NonEmptyReadonlyArray<Evt>) =>
-        getRequestContext
+        if (first) return first
+        yield* Effect.sleep(250)
+      }
+    }),
+    finish: Effect.fn(function*({ createdAt, updatedAt, ...q }: Drain) {
+      return yield* drainRepo.updateVoid(Drain.update.make({ ...q, finishedAt: Option.some(new Date()) })) // auto in lib , etag: crypto.randomUUID()
+    })
+  }
+  const queue = {
+    publish: Effect.fn("queue.publish: " + queueName, { kind: "producer" })(function*(
+      ...messages: NonEmptyReadonlyArray<Evt>
+    ) {
+      yield* Effect.annotateCurrentSpan({ "message_tags": messages.map((_) => _._tag) })
+      const requestContext = yield* getRequestContext
+      yield* Effect.forEach(messages, (m) => q.offer(m, requestContext), { discard: true })
+    }),
+    drain: <DrainE, DrainR>(
+      handleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
+      sessionId?: string
+    ) => {
+      const silenceAndReportError = reportNonInterruptedFailure({ name: "MemQueue.drain." + queueDrainName })
+      const processMessage = Effect.fnUntraced(function*({ body, meta }: Drain) {
+        let effect = InfraLogger
+          .logDebug(`[${queueDrainName}] Processing incoming message`)
           .pipe(
-            Effect.flatMap((requestContext) =>
-              Effect
-                .forEach(
-                  messages,
-                  (m) => q.offer(m, requestContext),
-                  {
-                    discard: true
+            Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
+            Effect.andThen(handleEvent(body)),
+            silenceAndReportError,
+            (_) =>
+              setupRequestContextWithCustomSpan(
+                _,
+                meta,
+                `queue.drain: ${queueDrainName}.${body._tag}`,
+                {
+                  captureStackTrace: false,
+                  kind: "consumer",
+                  attributes: {
+                    "queue.name": queueDrainName,
+                    "queue.sessionId": sessionId,
+                    "queue.input": body
                   }
-                )
-            ),
-            Effect.withSpan("queue.publish: " + queueName, {
-              kind: "producer",
-              attributes: { "message_tags": messages.map((_) => _._tag) }
-            }, { captureStackTrace: false })
-          ),
-      drain: <DrainE, DrainR>(
-        handleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
-        sessionId?: string
-      ) => {
-        const silenceAndReportError = reportNonInterruptedFailure({ name: "MemQueue.drain." + queueDrainName })
-        const processMessage = (msg: Drain) =>
-          Effect
-            .succeed(msg)
-            .pipe(Effect
-              .flatMap(({ body, meta }) => {
-                let effect = InfraLogger
-                  .logDebug(`[${queueDrainName}] Processing incoming message`)
-                  .pipe(
-                    Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
-                    Effect.andThen(handleEvent(body)),
-                    silenceAndReportError,
-                    (_) =>
-                      setupRequestContextWithCustomSpan(
-                        _,
-                        meta,
-                        `queue.drain: ${queueDrainName}.${body._tag}`,
-                        {
-                          captureStackTrace: false,
-                          kind: "consumer",
-                          attributes: {
-                            "queue.name": queueDrainName,
-                            "queue.sessionId": sessionId,
-                            "queue.input": body
-                          }
-                        }
-                      )
-                  )
-                if (meta.span) {
-                  effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
                 }
-                return effect
-              }))
-
-        return q
-          .take
-          .pipe(
-            Effect.flatMap((x) =>
-              processMessage(x).pipe(
-                Effect.uninterruptible,
-                Effect.forkChild,
-                Effect.flatMap(Fiber.join),
-                Effect.tap(q.finish(x))
               )
-            ),
-            silenceAndReportError,
-            Effect.withSpan(`queue.drain: ${queueDrainName}`, {
-              attributes: {
-                "queue.type": "sql",
-                "queue.name": queueDrainName,
-                "queue.sessionId": sessionId
-              }
-            }),
-            Effect.forever
           )
-      }
+        if (meta.span) {
+          effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
+        }
+        return yield* effect
+      })
+
+      return Effect.fn(`queue.drain: ${queueDrainName}`, {
+        attributes: { "queue.type": "sql", "queue.name": queueDrainName, "queue.sessionId": sessionId }
+      })(function*() {
+        const x = yield* q.take
+        yield* processMessage(x).pipe(
+          Effect.uninterruptible,
+          Effect.forkChild,
+          Effect.flatMap(Fiber.join),
+          Effect.tap(q.finish(x))
+        )
+      }, (effect) => effect.pipe(silenceAndReportError, Effect.forever))()
     }
-    return queue as QueueBase<Evt, DrainEvt>
-  })
-}
+  }
+  return queue as QueueBase<Evt, DrainEvt>
+})

package/src/QueueMaker/memQueue.ts

@@ -8,7 +8,7 @@ import { InfraLogger } from "../logger.js"
 import { reportNonInterruptedFailure, reportNonInterruptedFailureCause } from "./errors.js"
 import { type QueueBase, QueueMeta } from "./service.js"
 
-export function makeMemQueue<
+export const makeMemQueue = Effect.fnUntraced(function*<
   Evt extends { id: S.StringId; _tag: string },
   DrainEvt extends { id: S.StringId; _tag: string },
   EvtE,
@@ -19,112 +19,91 @@ export function makeMemQueue<
   schema: S.Codec<Evt, EvtE>,
   drainSchema: S.Codec<DrainEvt, DrainEvtE>
 ) {
-  return Effect.gen(function*() {
-    const mem = yield* MemQueue
-    const q = yield* mem.getOrCreateQueue(queueName)
-    const qDrain = yield* mem.getOrCreateQueue(queueDrainName)
+  const mem = yield* MemQueue
+  const q = yield* mem.getOrCreateQueue(queueName)
+  const qDrain = yield* mem.getOrCreateQueue(queueDrainName)
 
-    const wireSchema = S.Struct({ body: schema, meta: QueueMeta })
-    const wireSchemaJson = S.fromJsonString(S.toCodecJson(wireSchema))
-    const encodePublish = S.encodeEffect(wireSchemaJson)
-    const drainW = S.Struct({ body: drainSchema, meta: QueueMeta })
-    const drainWJson = S.fromJsonString(S.toCodecJson(drainW))
+  const wireSchema = S.Struct({ body: schema, meta: QueueMeta })
+  const wireSchemaJson = S.fromJsonString(S.toCodecJson(wireSchema))
+  const encodePublish = S.encodeEffect(wireSchemaJson)
+  const drainW = S.Struct({ body: drainSchema, meta: QueueMeta })
+  const drainWJson = S.fromJsonString(S.toCodecJson(drainW))
 
-    const parseDrain = flow(S.decodeUnknownEffect(drainWJson), Effect.orDie)
+  const parseDrain = flow(S.decodeUnknownEffect(drainWJson), Effect.orDie)
 
-    const queue = {
-      publish: (...messages: NonEmptyReadonlyArray<Evt>) =>
-        getRequestContext
-          .pipe(
-            Effect.flatMap((requestContext) =>
-              Effect
-                .forEach(messages, (m) =>
-                  // we JSON encode, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
-                  encodePublish({ body: m, meta: requestContext }).pipe(
-                    Effect.orDie,
-                    // .tap((msg) => info("Publishing Mem Message: " + utils.inspect(msg)))
-                    Effect.flatMap((_) => Q.offer(q, _))
-                  ), { discard: true })
-            ),
-            Effect.withSpan("queue.publish: " + queueName, {
-              kind: "producer",
-              attributes: { "message_tags": messages.map((_) => _._tag) }
-            }, { captureStackTrace: false })
-          ),
-      drain: <DrainE, DrainR>(
-        handleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
-        sessionId?: string
-      ) => {
-        const silenceAndReportError = reportNonInterruptedFailure({ name: "MemQueue.drain." + queueDrainName })
-        const reportError = reportNonInterruptedFailureCause({ name: "MemQueue.drain." + queueDrainName })
-        const processMessage = (msg: string) =>
-          // we JSON parse, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
-          parseDrain(msg).pipe(
+  const queue = {
+    publish: Effect.fn("queue.publish: " + queueName, { kind: "producer" })(function*(
+      ...messages: NonEmptyReadonlyArray<Evt>
+    ) {
+      yield* Effect.annotateCurrentSpan({ "message_tags": messages.map((_) => _._tag) })
+      const requestContext = yield* getRequestContext
+      // we JSON encode, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
+      yield* Effect.forEach(
+        messages,
+        (m) =>
+          encodePublish({ body: m, meta: requestContext }).pipe(
             Effect.orDie,
-            Effect
-              .flatMap(({ body, meta }) => {
-                let effect = InfraLogger
-                  .logDebug(`[${queueDrainName}] Processing incoming message`)
-                  .pipe(
-                    Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
-                    Effect.andThen(handleEvent(body)),
-                    silenceAndReportError,
-                    (_) =>
-                      setupRequestContextWithCustomSpan(
-                        _,
-                        meta,
-                        `queue.drain: ${queueDrainName}.${body._tag}`,
-                        {
-                          captureStackTrace: false,
-                          kind: "consumer",
-                          attributes: {
-                            "queue.name": queueDrainName,
-                            "queue.sessionId": sessionId,
-                            "queue.input": body
-                          }
-                        }
-                      )
-                  )
-                if (meta.span) {
-                  effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
-                }
-                return effect
-              })
-          )
-        return Q
-          .take(qDrain)
+            Effect.flatMap((_) => Q.offer(q, _))
+          ),
+        { discard: true }
+      )
+    }),
+    drain: <DrainE, DrainR>(
+      handleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
+      sessionId?: string
+    ) => {
+      const silenceAndReportError = reportNonInterruptedFailure({ name: "MemQueue.drain." + queueDrainName })
+      const reportError = reportNonInterruptedFailureCause({ name: "MemQueue.drain." + queueDrainName })
+      const processMessage = Effect.fnUntraced(function*(msg: string) {
+        // we JSON parse, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
+        const { body, meta } = yield* parseDrain(msg).pipe(Effect.orDie)
+        let effect = InfraLogger
+          .logDebug(`[${queueDrainName}] Processing incoming message`)
           .pipe(
-            Effect
-              .flatMap((x) =>
-                processMessage(x).pipe(
-                  Effect.uninterruptible,
-                  Effect.forkChild,
-                  Effect.flatMap(Fiber.join),
-                  // normally a failed item would be returned to the queue and retried up to X times.
-                  Effect.flatMap((_) =>
-                    _._tag === "Failure" && !Cause.hasInterruptsOnly(_.cause)
-                      ? Q.offer(qDrain, x).pipe(
-                        // TODO: retry count tracking and max retries.
-                        Effect.delay("5 seconds"),
-                        Effect.tapCause(reportError),
-                        Effect.forkDetach
-                      )
-                      : Effect.void
-                  )
-                )
-              ),
+            Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
+            Effect.andThen(handleEvent(body)),
             silenceAndReportError,
-            Effect.withSpan(`queue.drain: ${queueDrainName}`, {
-              attributes: {
-                "queue.type": "mem",
-                "queue.name": queueDrainName,
-                "queue.sessionId": sessionId
-              }
-            }),
-            Effect.forever
+            (_) =>
+              setupRequestContextWithCustomSpan(
+                _,
+                meta,
+                `queue.drain: ${queueDrainName}.${body._tag}`,
+                {
+                  captureStackTrace: false,
+                  kind: "consumer",
+                  attributes: {
+                    "queue.name": queueDrainName,
+                    "queue.sessionId": sessionId,
+                    "queue.input": body
+                  }
+                }
+              )
+          )
+        if (meta.span) {
+          effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
+        }
+        return yield* effect
+      })
+      return Effect.fn(`queue.drain: ${queueDrainName}`, {
+        attributes: { "queue.type": "mem", "queue.name": queueDrainName, "queue.sessionId": sessionId }
+      })(function*() {
+        const x = yield* Q.take(qDrain)
+        const exit = yield* processMessage(x).pipe(
+          Effect.uninterruptible,
+          Effect.forkChild,
+          Effect.flatMap(Fiber.join)
+        )
+        if (exit._tag === "Failure" && !Cause.hasInterruptsOnly(exit.cause)) {
+          // normally a failed item would be returned to the queue and retried up to X times.
+          yield* Q.offer(qDrain, x).pipe(
+            // TODO: retry count tracking and max retries.
+            Effect.delay("5 seconds"),
+            Effect.tapCause(reportError),
+            Effect.forkDetach
           )
-      }
+        }
+      }, (effect) => effect.pipe(silenceAndReportError, Effect.forever))()
     }
-    return queue as QueueBase<Evt, DrainEvt>
-  })
-}
+  }
+  return queue as QueueBase<Evt, DrainEvt>
+})

package/src/QueueMaker/sbqueue.ts

@@ -42,95 +42,65 @@ export function makeServiceBusQueue<
         handleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
         sessionId?: string
       ) => {
-        function processMessage(messageBody: unknown) {
-          return parseDrain(messageBody).pipe(
-            Effect.orDie,
-            Effect
-              .flatMap(({ body, meta }) => {
-                let effect = InfraLogger
-                  .logDebug(`[${receiver.name}] Processing incoming message`)
-                  .pipe(
-                    Effect.annotateLogs({
-                      body: pretty(body),
-                      meta: pretty(meta)
-                    }),
-                    Effect.andThen(handleEvent(body)),
-                    Effect.orDie
-                  )
-                  // we silenceAndReportError here, so that the error is reported, and moves into the Exit.
-                  .pipe(
-                    silenceAndReportError,
-                    (_) =>
-                      setupRequestContextWithCustomSpan(
-                        _,
-                        meta,
-                        `queue.drain: ${receiver.name}${sessionId ? `#${sessionId}` : ""}.${body._tag}`,
-                        {
-                          captureStackTrace: false,
-                          kind: "consumer",
-                          attributes: {
-                            "queue.name": receiver.name,
-                            "queue.sessionId": sessionId,
-                            "queue.input": body
-                          }
-                        }
-                      )
-                  )
-                if (meta.span) {
-                  effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
-                }
-                return effect
-              }),
-            Effect
-              // we reportError here, so that we report the error only, and keep flowing
-              .tapCause(reportError),
-            // we still need to flatten the Exit.
-            Effect.flatMap((_) => _)
-          )
-        }
+        const processMessage = Effect.fnUntraced(function*(messageBody: unknown) {
+          const { body, meta } = yield* parseDrain(messageBody).pipe(Effect.orDie)
+          let effect = InfraLogger
+            .logDebug(`[${receiver.name}] Processing incoming message`)
+            .pipe(
+              Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
+              Effect.andThen(handleEvent(body)),
+              Effect.orDie,
+              // we silenceAndReportError here, so that the error is reported, and moves into the Exit.
+              silenceAndReportError,
+              (_) =>
+                setupRequestContextWithCustomSpan(
+                  _,
+                  meta,
+                  `queue.drain: ${receiver.name}${sessionId ? `#${sessionId}` : ""}.${body._tag}`,
+                  {
+                    captureStackTrace: false,
+                    kind: "consumer",
+                    attributes: {
+                      "queue.name": receiver.name,
+                      "queue.sessionId": sessionId,
+                      "queue.input": body
+                    }
+                  }
+                )
+            )
+          if (meta.span) {
+            effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
+          }
+          // we reportError here, so that we report the error only, and keep flowing
+          const exit = yield* Effect.tapCause(effect, reportError)
+          return yield* exit
+        })
 
         return receiver
           .subscribe({
             processMessage: (x) => processMessage(x.body).pipe(Effect.uninterruptible),
             processError: (err) => reportQueueError(Cause.fail(err.error))
-            // Deferred.completeWith(
-            //   deferred,
-            //   reportFatalQueueError(Cause.fail(err.error))
-            //     .pipe(Effect.andThen(Effect.fail(err.error)))
-            // )
           }, sessionId)
-          // .pipe(Effect.andThen(Deferred.await(deferred).pipe(Effect.orDie))),
-          .pipe(
-            Effect.andThen(Effect.never)
-          )
+          .pipe(Effect.andThen(Effect.never))
       },
 
-      publish: (...messages: NonEmptyReadonlyArray<Evt>) =>
-        getRequestContext
-          .pipe(
-            Effect.flatMap((requestContext) =>
-              Effect
-                .forEach(messages, (m) =>
-                  encodePublish({
-                    body: m,
-                    meta: requestContext
-                  })
-                    .pipe(
-                      Effect.orDie,
-                      Effect.map((body) => ({
-                        body,
-                        messageId: m.id, /* correllationid: requestId */
-                        contentType: "application/json",
-                        sessionId: "sessionId" in m ? m.sessionId as string : undefined as unknown as string // TODO: optional
-                      }))
-                    ))
-                .pipe(Effect.flatMap((msgs) => sender.sendMessages(msgs)))
-            ),
-            Effect.withSpan("queue.publish: " + sender.name, {
-              kind: "producer",
-              attributes: { "message_tags": messages.map((_) => _._tag) }
-            }, { captureStackTrace: false })
-          )
+      publish: Effect.fn("queue.publish: " + sender.name, {
+        kind: "producer"
+      })(function*(...messages: NonEmptyReadonlyArray<Evt>) {
+        yield* Effect.annotateCurrentSpan({ "message_tags": messages.map((_) => _._tag) })
+        const requestContext = yield* getRequestContext
+        const msgs = yield* Effect.forEach(messages, (m) =>
+          encodePublish({ body: m, meta: requestContext }).pipe(
+            Effect.orDie,
+            Effect.map((body) => ({
+              body,
+              messageId: m.id, /* correllationid: requestId */
+              contentType: "application/json",
+              sessionId: "sessionId" in m ? m.sessionId as string : undefined as unknown as string // TODO: optional
+            }))
+          ))
+        yield* sender.sendMessages(msgs)
+      })
     }
     return queue as QueueBase<Evt, DrainEvt>
   })