@effect-app/infra 4.0.0-beta.24 → 4.0.0-beta.241

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 * as S from "effect-app/Schema"
 import type { StringId } from "effect-app/Schema"
 import { pretty } from "effect-app/utils"
+import * as Cause from "effect/Cause"
+import { flow } from "effect/Function"
+import * as Tracer from "effect/Tracer"
 import { Receiver, Sender } from "../adapters/ServiceBus.js"
 import { getRequestContext, setupRequestContextWithCustomSpan } from "../api/setupRequest.js"
 import { InfraLogger } from "../logger.js"
+import { messagingSpanArgs } from "../otel.js"
 import { reportNonInterruptedFailure, reportNonInterruptedFailureCause, reportQueueError } from "./errors.js"
-import { type QueueBase, QueueMeta } from "./service.js"
+import { 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/QueueMaker/service.ts

@@ -1,4 +1,6 @@
-import type { Effect, NonEmptyReadonlyArray, Scope } from "effect-app"
+import type { NonEmptyReadonlyArray } from "effect-app/Array"
+import type * as Effect from "effect-app/Effect"
+import type * as Scope from "effect/Scope"
 import { RequestContext } from "../RequestContext.js"
 
 export interface QueueBase<Evt, DrainEvt> {

package/src/RequestContext.ts

@@ -1,16 +1,17 @@
-import { S, ServiceMap } from "effect-app"
+import * as Context from "effect-app/Context"
 import { UserProfileId } from "effect-app/ids"
+import * as S from "effect-app/Schema"
 import { NonEmptyString255 } from "effect-app/Schema"
 
-export const Locale = S.Literal("en", "de")
+export const Locale = S.Literals(["en", "de"])
 export type Locale = typeof Locale.Type
 
-export class LocaleRef extends ServiceMap.Reference("Locale", { defaultValue: (): Locale => "en" }) {}
+export class LocaleRef extends Context.Reference("Locale", { defaultValue: (): Locale => "en" }) {}
 
-export class RequestContext extends S.ExtendedClass<
+export class RequestContext extends S.Opaque<
   RequestContext,
   RequestContext.Encoded
->("RequestContext")({
+>()(S.Struct({
   span: S.Struct({
     traceId: S.String,
     spanId: S.String,
@@ -22,8 +23,8 @@ export class RequestContext extends S.ExtendedClass<
   namespace: NonEmptyString255,
   /** @deprecated */
   userProfile: S.optional(S.Struct({ sub: UserProfileId })) //
-}) {
-  // static Tag = ServiceMap.Tag<RequestContext>()
+})) {
+  // static Tag = Context.Tag<RequestContext>()
 
   static toMonitoring(this: void, self: RequestContext) {
     return {
@@ -34,16 +35,16 @@ export class RequestContext extends S.ExtendedClass<
 }
 
 export const spanAttributes = (ctx: Pick<RequestContext, "locale" | "namespace"> & Partial<RequestContext>) => ({
-  "request.name": ctx.name,
-  "request.locale": ctx.locale,
-  "request.namespace": ctx.namespace,
-  ...ctx.sourceId ? { "request.source.id": ctx.sourceId } : {},
+  "code.function.name": ctx.name,
+  "app.locale": ctx.locale,
+  "app.tenant.id": ctx.namespace,
+  ...ctx.sourceId ? { "client.id": ctx.sourceId } : {},
   ...(ctx.userProfile?.sub
     ? {
-      "request.user.sub": ctx
+      "user.id": ctx
         .userProfile
         .sub,
-      "request.user.roles": "roles" in ctx
+      "user.roles": "roles" in ctx
           .userProfile
         ? ctx.userProfile.roles
         : undefined
@@ -53,11 +54,9 @@ export const spanAttributes = (ctx: Pick<RequestContext, "locale" | "namespace">
 
 // codegen:start {preset: model}
 //
-/* eslint-disable */
 export namespace RequestContext {
-  export interface Encoded extends S.Struct.Encoded<typeof RequestContext["fields"]> {}
+  export interface Encoded extends S.StructNestedEncoded<typeof RequestContext> {}
 }
-/* eslint-enable */
 //
 // codegen:end
 //

package/src/RequestFiberSet.ts

@@ -1,5 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, Fiber, FiberSet, Layer, Option, ServiceMap, type Tracer } from "effect-app"
+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 { reportRequestError, reportUnknownRequestError } from "./api/reportError.js"
 import { InfraLogger } from "./logger.js"
 
@@ -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/Store/ContextMapContainer.ts

@@ -1,4 +1,10 @@
-import { Data, Effect, Layer, ServiceMap } from "effect-app"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import * as Data from "effect/Data"
+import { dual } from "effect/Function"
+import type * as Request from "effect/Request"
+import * as RequestResolver from "effect/RequestResolver"
 import { ContextMap } from "./service.js"
 
 // TODO: we have to create a new contextmap on every request.
@@ -7,7 +13,7 @@ import { ContextMap } from "./service.js"
 // we can call another start after startup. but it would be even better if we could Die on accessing rootmap
 // we could also make the ContextMap optional, and when missing, issue a warning instead?
 
-export class ContextMapContainer extends ServiceMap.Reference("ContextMapContainer", {
+export class ContextMapContainer extends Context.Reference("ContextMapContainer", {
   defaultValue: (): ContextMap | "root" => "root"
 }) {
   static readonly layer = Layer.effect(this, ContextMap.make.pipe(Effect.map(ContextMap.of)))
@@ -15,6 +21,43 @@ export class ContextMapContainer extends ServiceMap.Reference("ContextMapContain
 
 export class ContextMapNotStartedError extends Data.TaggedError("ContextMapNotStartedError") {}
 
-export const getContextMap = ContextMapContainer.asEffect().pipe(
+export const getContextMap = ContextMapContainer.pipe(
   Effect.filterOrFail((_) => _ !== "root", () => new ContextMapNotStartedError())
 )
+
+/**
+ * Uses the official `RequestResolver.withCache` internally,
+ * creating one cached resolver per ContextMap (i.e. per request).
+ * Uses a shared semaphore in the ContextMap to ensure safe single initialization.
+ */
+export const withRequestResolverCache: {
+  <A extends Request.Request<any, any>>(options: {
+    readonly capacity: number
+    readonly strategy?: "lru" | "fifo" | undefined
+  }): (
+    self: RequestResolver.RequestResolver<A>
+  ) => Effect.Effect<RequestResolver.RequestResolver<A>, ContextMapNotStartedError>
+  <A extends Request.Request<any, any>>(
+    self: RequestResolver.RequestResolver<A>,
+    options: {
+      readonly capacity: number
+      readonly strategy?: "lru" | "fifo" | undefined
+    }
+  ): Effect.Effect<RequestResolver.RequestResolver<A>, ContextMapNotStartedError>
+} = dual(2, <A extends Request.Request<any, any>>(
+  self: RequestResolver.RequestResolver<A>,
+  options: {
+    readonly capacity: number
+    readonly strategy?: "lru" | "fifo" | undefined
+  }
+): Effect.Effect<RequestResolver.RequestResolver<A>, ContextMapNotStartedError> => {
+  const cacheKey = Symbol()
+  return getContextMap.pipe(
+    Effect.flatMap((ctxMap) =>
+      ctxMap.getOrCreateStoreEffect(
+        cacheKey,
+        RequestResolver.withCache(self, options)
+      )
+    )
+  )
+})