@effect-app/infra 4.0.0-beta.25 → 4.0.0-beta.250

package/src/QueueMaker/sbqueue.ts

@@ -1,12 +1,17 @@
-import { Tracer } from "effect"
-import { Cause, Effect, flow, type NonEmptyReadonlyArray, S } from "effect-app"
+import type { NonEmptyReadonlyArray } from "effect-app/Array"
+import * as Effect from "effect-app/Effect"
+import { QueueMeta } from "effect-app/QueueMaker"
+import * as S from "effect-app/Schema"
 import type { StringId } from "effect-app/Schema"
 import { pretty } from "effect-app/utils"
-import { Receiver, Sender } from "../adapters/ServiceBus.js"
-import { getRequestContext, setupRequestContextWithCustomSpan } from "../api/setupRequest.js"
+import * as Cause from "effect/Cause"
+import { flow } from "effect/Function"
+import * as Tracer from "effect/Tracer"
 import { InfraLogger } from "../logger.js"
+import { messagingSpanArgs } from "../otel.js"
+import { Receiver, Sender } from "../ServiceBus.js"
+import { getRequestContext, setupRequestContextWithCustomSpan } from "../setupRequest.js"
 import { reportNonInterruptedFailure, reportNonInterruptedFailureCause, reportQueueError } from "./errors.js"
-import { type QueueBase, QueueMeta } from "./service.js"
 
 export function makeServiceBusQueue<
   Evt extends { id: StringId; _tag: string },
@@ -21,11 +26,11 @@ export function makeServiceBusQueue<
     body: schema,
     meta: QueueMeta
   })
-  const wireSchemaJson = S.fromJsonString(wireSchema)
+  const wireSchemaJson = S.fromJsonString(S.toCodecJson(wireSchema))
   const encodePublish = S.encodeEffect(wireSchemaJson)
   const drainW = S.Struct({ body: drainSchema, meta: QueueMeta })
-  const drainWJson = S.fromJsonString(drainW)
-  const parseDrain = flow(S.decodeUnknownEffect(drainWJson), Effect.orDie)
+  const drainWJson = S.fromJsonString(S.toCodecJson(drainW))
+  const parseDrain = flow(S.decodeUnknownEffectConcurrently(drainWJson), Effect.orDie)
 
   return Effect.gen(function*() {
     const sender = yield* Sender
@@ -42,96 +47,79 @@ 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,
+              (_) => {
+                const args = messagingSpanArgs({
+                  operation: "process",
+                  system: "servicebus",
+                  destination: receiver.name,
+                  messageId: body.id,
+                  conversationId: sessionId,
+                  extra: { "messaging.message.type": body._tag, "messaging.message.body": body }
+                }, "consumer")
+                return setupRequestContextWithCustomSpan(
+                  _,
+                  meta,
+                  args.name,
+                  {
+                    captureStackTrace: false,
+                    kind: args.kind,
+                    attributes: args.attributes
+                  }
+                )
+              }
+            )
+          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(`publish ${sender.name}`, {
+        kind: "producer",
+        attributes: {
+          "messaging.system": "servicebus",
+          "messaging.operation.name": "publish",
+          "messaging.destination.name": sender.name
+        }
+      })(function*(...messages: NonEmptyReadonlyArray<Evt>) {
+        yield* Effect.annotateCurrentSpan({
+          "messaging.batch.message_count": messages.length,
+          "messaging.message.types": 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>
+    return queue
   })
 }

package/src/RequestFiberSet.ts

@@ -1,7 +1,13 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, Fiber, FiberSet, Layer, Option, ServiceMap, type Tracer } from "effect-app"
-import { reportRequestError, reportUnknownRequestError } from "./api/reportError.js"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import * as Option from "effect-app/Option"
+import * as Fiber from "effect/Fiber"
+import * as FiberSet from "effect/FiberSet"
+import type * as Tracer from "effect/Tracer"
 import { InfraLogger } from "./logger.js"
+import { reportRequestError, reportUnknownRequestError } from "./reportError.js"
 
 const getRootParentSpan = Effect.gen(function*() {
   let span: Tracer.AnySpan | null = yield* Effect.currentSpan.pipe(
@@ -92,14 +98,13 @@ const make = Effect.gen(function*() {
  * Whenever you fork a fiber for a Request, and you want to prevent dependent services to close prematurely on interruption,
  * like the ServiceBus Sender, you should register these fibers in this FiberSet.
  */
-export class RequestFiberSet extends ServiceMap.Service<RequestFiberSet>()("RequestFiberSet", { make }) {
+export class RequestFiberSet extends Context.Service<RequestFiberSet>()("RequestFiberSet", { make }) {
   static readonly Live = Layer.effect(this, this.make)
   static readonly register = <A, E, R>(self: Effect.Effect<A, E, R>) =>
-    this.asEffect().pipe(Effect.andThen((_) => _.register(self)))
-  static readonly run = <A, E, R>(self: Effect.Effect<A, E, R>) =>
-    this.asEffect().pipe(Effect.andThen((_) => _.run(self)))
+    this.pipe(Effect.andThen((_) => _.register(self)))
+  static readonly run = <A, E, R>(self: Effect.Effect<A, E, R>) => this.pipe(Effect.andThen((_) => _.run(self)))
   static readonly forkDaemonReport = <R, E, A>(self: Effect.Effect<A, E, R>) =>
-    this.asEffect().pipe(Effect.andThen((_) => _.forkDaemonReport(self)))
+    this.pipe(Effect.andThen((_) => _.forkDaemonReport(self)))
   static readonly forkDaemonReportUnexpected = <R, E, A>(self: Effect.Effect<A, E, R>) =>
-    this.asEffect().pipe(Effect.andThen((_) => _.forkDaemonReportUnexpected(self)))
+    this.pipe(Effect.andThen((_) => _.forkDaemonReportUnexpected(self)))
 }

package/src/{adapters/SQL → SQL}/Model.ts

@@ -24,6 +24,7 @@ import * as VariantSchema from "effect/unstable/schema/VariantSchema"
 import { SqlClient } from "effect/unstable/sql/SqlClient"
 import * as SqlResolver from "effect/unstable/sql/SqlResolver"
 import * as SqlSchema from "effect/unstable/sql/SqlSchema"
+import { type DbSystem, withDbSpan } from "../otel.js"
 
 const {
   Class,
@@ -73,7 +74,7 @@ export {
    * @since 1.0.0
    * @category constructors
    * @example
-   * import { Schema } from "effect"
+   * import * as Schema from "effect/Schema"
    * import { Model } from "effect/unstable/schema"
    *
    * export const GroupId = Schema.Number.pipe(Schema.brand("GroupId"))
@@ -545,9 +546,15 @@ export const DateTimeUpdateFromNumber: DateTimeUpdateFromNumber = Field({
  */
 export interface JsonFromString<S extends Schema.Top> extends
   VariantSchema.Field<{
-    readonly select: Schema.fromJsonString<S>
-    readonly insert: Schema.fromJsonString<S>
-    readonly update: Schema.fromJsonString<S>
+    readonly select: Schema.fromJsonString<
+      Schema.Codec<S["Type"], Schema.Json, S["DecodingServices"], S["EncodingServices"]>
+    >
+    readonly insert: Schema.fromJsonString<
+      Schema.Codec<S["Type"], Schema.Json, S["DecodingServices"], S["EncodingServices"]>
+    >
+    readonly update: Schema.fromJsonString<
+      Schema.Codec<S["Type"], Schema.Json, S["DecodingServices"], S["EncodingServices"]>
+    >
     readonly json: S
     readonly jsonCreate: S
     readonly jsonUpdate: S
@@ -565,7 +572,7 @@ export interface JsonFromString<S extends Schema.Top> extends
 export const JsonFromString = <S extends Schema.Top>(
   schema: S
 ): JsonFromString<S> => {
-  const parsed = Schema.fromJsonString(schema)
+  const parsed = Schema.fromJsonString(Schema.toCodecJson(schema))
   return Field({
     select: parsed,
     insert: parsed,
@@ -590,6 +597,7 @@ export const makeRepository = <
   readonly spanPrefix: string
   readonly idColumn: Id
   readonly versionColumn?: string | undefined
+  readonly dbSystem?: DbSystem | undefined
 }): Effect.Effect<
   {
     readonly insert: (
@@ -623,6 +631,15 @@ export const makeRepository = <
     const idSchema = Model.fields[options.idColumn] as Schema.Top
     const idColumn = options.idColumn as string
     const versionColumn = options.versionColumn
+    const system: DbSystem = options.dbSystem ?? "other_sql"
+    const opSpan = (operation: string, idValue?: unknown) =>
+      withDbSpan({
+        operation,
+        system,
+        collection: options.tableName,
+        entity: options.spanPrefix,
+        ...(idValue !== undefined && { extra: { "app.entity.id": idValue } })
+      })
 
     const insertSchema = SqlSchema.findOne({
       Request: Model.insert,
@@ -644,9 +661,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
     ): Effect.Effect<S["Type"], Schema.SchemaError, S["DecodingServices"] | S["insert"]["EncodingServices"]> =>
       insertSchema(insert).pipe(
         Effect.catchTag("NoSuchElementError", Effect.die),
-        Effect.withSpan(`${options.spanPrefix}.insert`, {}, {
-          captureStackTrace: false
-        })
+        opSpan("insert")
       ) as any
 
     const insertVoidSchema = SqlSchema.void({
@@ -657,9 +672,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
       insert: S["insert"]["Type"]
     ): Effect.Effect<void, Schema.SchemaError, S["insert"]["EncodingServices"]> =>
       insertVoidSchema(insert).pipe(
-        Effect.withSpan(`${options.spanPrefix}.insertVoid`, {}, {
-          captureStackTrace: false
-        })
+        opSpan("insertVoid")
       ) as any
 
     const updateSchema = SqlSchema.findOne({
@@ -706,11 +719,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${request[idCol
     ): Effect.Effect<S["Type"], Schema.SchemaError, S["DecodingServices"] | S["update"]["EncodingServices"]> =>
       updateSchema(update).pipe(
         Effect.catchTag("NoSuchElementError", Effect.die),
-        Effect.withSpan(`${options.spanPrefix}.update`, {
-          attributes: { id: (update as any)[idColumn] }
-        }, {
-          captureStackTrace: false
-        })
+        opSpan("update", (update as any)[idColumn])
       ) as any
 
     const updateVoidSchema = SqlSchema.void({
@@ -729,11 +738,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${request[idCol
       update: S["update"]["Type"]
     ): Effect.Effect<void, Schema.SchemaError, S["update"]["EncodingServices"]> =>
       updateVoidSchema(update).pipe(
-        Effect.withSpan(`${options.spanPrefix}.updateVoid`, {
-          attributes: { id: (update as any)[idColumn] }
-        }, {
-          captureStackTrace: false
-        })
+        opSpan("updateVoid", (update as any)[idColumn])
       ) as any
 
     const findByIdSchema = SqlSchema.findOneOption({
@@ -749,9 +754,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${request[idCol
       S["DecodingServices"] | S["fields"][Id]["EncodingServices"]
     > =>
       findByIdSchema(id).pipe(
-        Effect.withSpan(`${options.spanPrefix}.findById`, { attributes: { id } }, {
-          captureStackTrace: false
-        })
+        opSpan("findById", id)
       ) as any
 
     const deleteSchema = SqlSchema.void({
@@ -762,11 +765,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${request[idCol
       id: S["fields"][Id]["Type"]
     ): Effect.Effect<void, Schema.SchemaError, S["fields"][Id]["EncodingServices"]> =>
       deleteSchema(id).pipe(
-        Effect.withSpan(`${options.spanPrefix}.delete`, {
-          attributes: { id }
-        }, {
-          captureStackTrace: false
-        })
+        opSpan("delete", id)
       ) as any
 
     return { insert, insertVoid, update, updateVoid, findById, delete: delete_ } as const
@@ -789,6 +788,7 @@ export const makeDataLoaders = <
     readonly idColumn: Id
     readonly window: Input
     readonly maxBatchSize?: number | undefined
+    readonly dbSystem?: DbSystem | undefined
   }
 ): Effect.Effect<
   {
@@ -821,6 +821,15 @@ export const makeDataLoaders = <
     const idSchema = Model.fields[options.idColumn] as Schema.Top
     const idColumn = options.idColumn as string
     const setMaxBatchSize = options.maxBatchSize ? RequestResolver.batchN(options.maxBatchSize) : identity
+    const system: DbSystem = options.dbSystem ?? "other_sql"
+    const opSpan = (operation: string, idValue?: unknown) =>
+      withDbSpan({
+        operation,
+        system,
+        collection: options.tableName,
+        entity: options.spanPrefix,
+        ...(idValue !== undefined && { extra: { "app.entity.id": idValue } })
+      })
 
     const insertResolver = SqlResolver
       .ordered({
@@ -854,9 +863,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
     > =>
       insertExecute(insert).pipe(
         Effect.catchTag("ResultLengthMismatch", Effect.die),
-        Effect.withSpan(`${options.spanPrefix}.insert`, {}, {
-          captureStackTrace: false
-        })
+        opSpan("insert")
       ) as any
 
     const insertVoidResolver = SqlResolver
@@ -874,9 +881,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
       insert: S["insert"]["Type"]
     ): Effect.Effect<void, Schema.SchemaError, S["insert"]["EncodingServices"]> =>
       insertVoidExecute(insert).pipe(
-        Effect.withSpan(`${options.spanPrefix}.insertVoid`, {}, {
-          captureStackTrace: false
-        })
+        opSpan("insertVoid")
       ) as any
 
     const findByIdResolver = SqlResolver
@@ -902,9 +907,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
       S["DecodingServices"] | S["fields"][Id]["EncodingServices"]
     > =>
       findByIdExecute(id).pipe(
-        Effect.withSpan(`${options.spanPrefix}.findById`, { attributes: { id } }, {
-          captureStackTrace: false
-        })
+        opSpan("findById", id)
       ) as any
 
     const deleteResolver = SqlResolver
@@ -922,9 +925,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
       id: S["fields"][Id]["Type"]
     ): Effect.Effect<void, Schema.SchemaError, S["fields"][Id]["EncodingServices"]> =>
       deleteExecute(id).pipe(
-        Effect.withSpan(`${options.spanPrefix}.delete`, { attributes: { id } }, {
-          captureStackTrace: false
-        })
+        opSpan("delete", id)
       ) as any
 
     return { insert, insertVoid, findById, delete: delete_ } as const

package/src/ServiceBus.ts

@@ -0,0 +1,219 @@
+/* eslint-disable @typescript-eslint/prefer-promise-reject-errors */
+import { type OperationOptionsBase, type ProcessErrorArgs, ServiceBusClient, type ServiceBusMessage, type ServiceBusMessageBatch, type ServiceBusReceivedMessage, type ServiceBusReceiver } from "@azure/service-bus"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import * as Cause from "effect/Cause"
+import * as Exit from "effect/Exit"
+import * as FiberSet from "effect/FiberSet"
+import type * as Scope from "effect/Scope"
+import { InfraLogger } from "./logger.js"
+
+const logged = (name: string) => <A, E, R>(self: Effect.Effect<A, E, R>) =>
+  Effect.logInfo(name).pipe(
+    Effect.andThen(self),
+    Effect.tap(Effect.logInfo(name + " done")),
+    Effect.withLogSpan(name)
+  )
+
+function makeClient(url: string) {
+  return Effect.acquireRelease(
+    Effect.sync(() => new ServiceBusClient(url)).pipe(logged("ServiceBus.client.create")),
+    (client) => Effect.promise(() => client.close()).pipe(logged("ServiceBus.client.close"))
+  )
+}
+
+export class ServiceBusClientTag
+  extends Context.Opaque<ServiceBusClientTag, ServiceBusClient>()("@services/Client", { make: makeClient })
+{
+  static readonly layer = (url: string) => this.toLayer(this.make(url))
+}
+
+const makeSender_ = Effect.fnUntraced(function*(queueName: string) {
+  const serviceBusClient = yield* ServiceBusClientTag
+
+  return yield* Effect.acquireRelease(
+    Effect.sync(() => serviceBusClient.createSender(queueName)).pipe(
+      logged(`ServiceBus.sender.create ${queueName}`)
+    ),
+    (sender) => Effect.promise(() => sender.close()).pipe(logged(`ServiceBus.sender.close ${queueName}`))
+  )
+})
+
+const makeSender = Effect.fnUntraced(function*(name: string) {
+  const sender = yield* makeSender_(name)
+  const sendMessages = Effect.fnUntraced(function*(
+    messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
+    options?: Omit<OperationOptionsBase, "abortSignal">
+  ) {
+    return yield* Effect.promise((abortSignal) => sender.sendMessages(messages, { ...options, abortSignal }))
+  })
+
+  return { name, sendMessages }
+})
+
+export class Sender extends Context.Opaque<Sender, {
+  name: string
+  sendMessages: (
+    messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
+    options?: Omit<OperationOptionsBase, "abortSignal">
+  ) => Effect.Effect<void>
+}>()("Sender", { make: makeSender }) {
+  static readonly layer = (name: string) => this.toLayer(this.make(name))
+}
+
+export const SenderTag = <Id>() => <Key extends string>(queueName: Key) => {
+  const tag = Context.Service<Id, Sender>(`ServiceBus.Sender.${queueName}`)
+
+  return Object.assign(tag, {
+    layer: Layer.effect(
+      tag,
+      Sender.make(queueName).pipe(Effect.map(Sender.of))
+    )
+  })
+}
+
+const makeReceiver = Effect.fnUntraced(function*(name: string) {
+  const serviceBusClient = yield* ServiceBusClientTag
+
+  const makeReceiver = Effect.fnUntraced(
+    function*(queueName: string, waitTillEmpty: Effect.Effect<void>, sessionId?: string) {
+      const annotate = sessionId !== undefined
+        ? Effect.annotateLogs({ "messaging.session.id": sessionId })
+        : <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => self
+      return yield* Effect.acquireRelease(
+        (sessionId
+          ? Effect.promise(() => serviceBusClient.acceptSession(queueName, sessionId))
+          : Effect.sync(() => serviceBusClient.createReceiver(queueName)))
+          .pipe(logged(`ServiceBus.receiver.create ${queueName}`), annotate),
+        (r) =>
+          waitTillEmpty.pipe(
+            logged(`ServiceBus.receiver.waitTillEmpty ${queueName}`),
+            Effect.andThen(
+              Effect.promise(() => r.close()).pipe(
+                logged(`ServiceBus.receiver.close ${queueName}`)
+              )
+            ),
+            logged(`ServiceBus.receiver.release ${queueName}`),
+            annotate
+          )
+      )
+    }
+  )
+
+  const make = (waitTillEmpty: Effect.Effect<void>) => makeReceiver(name, waitTillEmpty)
+
+  const makeSession = (sessionId: string, waitTillEmpty: Effect.Effect<void>) =>
+    makeReceiver(name, waitTillEmpty, sessionId)
+
+  return {
+    name,
+    make,
+    makeSession,
+    subscribe: Effect.fnUntraced(function*<RMsg, RErr>(hndlr: MessageHandlers<RMsg, RErr>, sessionId?: string) {
+      const fs = yield* FiberSet.make()
+      const fr = yield* FiberSet.runtime(fs)<RMsg | RErr>()
+      const wait = Effect
+        .gen(function*() {
+          if ((yield* FiberSet.size(fs)) > 0) {
+            yield* InfraLogger.logDebug("Waiting ServiceBusFiberSet to be empty: " + (yield* FiberSet.size(fs)))
+          }
+          while ((yield* FiberSet.size(fs)) > 0) yield* Effect.sleep("250 millis")
+        })
+      const r = yield* sessionId
+        ? makeSession(
+          sessionId,
+          wait
+        )
+        : make(wait)
+
+      const runEffect = <E>(effect: Effect.Effect<void, E, RMsg | RErr>) =>
+        new Promise<void>((resolve, reject) =>
+          fr(effect)
+            .addObserver((exit) => {
+              if (Exit.isSuccess(exit)) {
+                resolve(exit.value)
+              } else {
+                // disable @typescript-eslint/prefer-promise-reject-errors
+                reject(Cause.pretty(exit.cause))
+              }
+            })
+        )
+
+      const annotate = sessionId !== undefined
+        ? Effect.annotateLogs({ "messaging.session.id": sessionId })
+        : <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => self
+      yield* Effect.acquireRelease(
+        Effect
+          .sync(() => {
+            const s = r
+              .subscribe({
+                processError: (err) =>
+                  runEffect(
+                    hndlr
+                      .processError(err)
+                      .pipe(
+                        Effect.catchCause((cause) => Effect.logError("ServiceBus Error", cause)),
+                        annotate
+                      )
+                  ),
+                processMessage: (msg) => runEffect(hndlr.processMessage(msg).pipe(annotate))
+                // DO NOT CATCH ERRORS here as they should return to the queue!
+              })
+            return { close: Effect.promise(() => s.close()) }
+          })
+          .pipe(logged("ServiceBus.subscription.create"), annotate),
+        (subscription) =>
+          subscription.close.pipe(
+            logged("ServiceBus.subscription.close"),
+            annotate
+          )
+      ) as Effect.Effect<void, never, Scope.Scope> // wth is going on here
+    })
+  }
+})
+
+export class Receiver extends Context.Opaque<Receiver, {
+  name: string
+  make: (waitTillEmpty: Effect.Effect<void>) => Effect.Effect<ServiceBusReceiver, never, Scope.Scope>
+  makeSession: (
+    sessionId: string,
+    waitTillEmpty: Effect.Effect<void>
+  ) => Effect.Effect<ServiceBusReceiver, never, Scope.Scope>
+  subscribe<RMsg, RErr>(
+    hndlr: MessageHandlers<RMsg, RErr>,
+    sessionId?: string
+  ): Effect.Effect<void, never, Scope.Scope | RMsg | RErr>
+}>()("Receiver") {
+  static readonly make = makeReceiver
+  static readonly layer = (name: string) => this.toLayer(makeReceiver(name))
+}
+
+export const ReceiverTag = <Id>() => <Key extends string>(queueName: Key) => {
+  const tag = Context.Service<Id, Receiver>(`ServiceBus.Receiver.${queueName}`)
+
+  return Object.assign(tag, {
+    layer: Layer.effect(
+      tag,
+      makeReceiver(queueName).pipe(Effect.map(Receiver.of))
+    )
+  })
+}
+
+export const SenderReceiver = (queue: string, queueDrain?: string) =>
+  Layer.mergeAll(Sender.layer(queue), Receiver.layer(queueDrain ?? queue))
+
+export interface MessageHandlers<RMsg, RErr> {
+  /**
+   * Handler that processes messages from service bus.
+   *
+   * @param message - A message received from Service Bus.
+   */
+  processMessage(message: ServiceBusReceivedMessage): Effect.Effect<void, never, RMsg>
+  /**
+   * Handler that processes errors that occur during receiving.
+   * @param args - The error and additional context to indicate where
+   * the error originated.
+   */
+  processError(args: ProcessErrorArgs): Effect.Effect<void, never, RErr>
+}