@effect-app/infra 4.0.0-beta.209 → 4.0.0-beta.210

package/src/Model/Repository/internal/internal.ts

@@ -76,7 +76,7 @@ export function makeRepoInternal<
           const encodeMany = flow(
             S.encodeEffect(S.Array(schema)),
             provideRctx,
-            Effect.withSpan("encodeMany", { attributes: { itemType: name } }, { captureStackTrace: false })
+            Effect.withSpan("encodeMany", { attributes: { "app.entity": name } }, { captureStackTrace: false })
           )
           const decode = flow(S.decodeEffectConcurrently(schema), provideRctx)
           const decodeMany = flow(
@@ -140,7 +140,7 @@ export function makeRepoInternal<
               Effect.map((_: Record<string, unknown>) => _[idKey as string] as Encoded[IdKey])
             )
           const findEId = Effect.fnUntraced(function*(id: Encoded[IdKey]) {
-            yield* Effect.annotateCurrentSpan({ itemId: id })
+            yield* Effect.annotateCurrentSpan({ "app.entity.id": id })
 
             return yield* Effect.flatMap(
               store.find(id),
@@ -153,7 +153,7 @@ export function makeRepoInternal<
           })
           // TODO: select the particular field, instead of as struct
           const findE = Effect.fnUntraced(function*(id: T[IdKey]) {
-            yield* Effect.annotateCurrentSpan({ itemId: id })
+            yield* Effect.annotateCurrentSpan({ "app.entity.id": id })
 
             return yield* pipe(
               encodeId({ [idKey]: id } as any),
@@ -163,8 +163,8 @@ export function makeRepoInternal<
             )
           })
 
-          const find = Effect.fn("find", { attributes: { itemType: name } })(function*(id: T[IdKey]) {
-            yield* Effect.annotateCurrentSpan({ itemId: id })
+          const find = Effect.fn("find", { attributes: { "app.entity": name } })(function*(id: T[IdKey]) {
+            yield* Effect.annotateCurrentSpan({ "app.entity.id": id })
 
             return yield* flatMapOption(findE(id), (_) => Effect.orDie(decode(_)))
           })
@@ -190,11 +190,14 @@ export function makeRepoInternal<
                 Effect.andThen(saveAllE)
               )
 
-          const saveAndPublish = Effect.fn("saveAndPublish", { attributes: { itemType: name } })(
+          const saveAndPublish = Effect.fn("saveAndPublish", { attributes: { "app.entity": name } })(
             function*(items: Iterable<T>, events: Iterable<Evt> = []) {
               const it = Chunk.fromIterable(items)
               const evts = [...events]
-              yield* Effect.annotateCurrentSpan({ itemIds: Chunk.map(it, (_) => _[idKey]), events: evts.length })
+              yield* Effect.annotateCurrentSpan({
+                "app.entity.ids": Chunk.map(it, (_) => _[idKey]),
+                "app.event.count": evts.length
+              })
               return yield* saveAll(it)
                 .pipe(
                   Effect.andThen(Effect.sync(() => toNonEmptyArray(evts))),
@@ -206,12 +209,15 @@ export function makeRepoInternal<
             }
           )
 
-          const removeAndPublish = Effect.fn("removeAndPublish", { attributes: { itemType: name } })(
+          const removeAndPublish = Effect.fn("removeAndPublish", { attributes: { "app.entity": name } })(
             function*(a: Iterable<T>, events: Iterable<Evt> = []) {
               const { set } = yield* cms
               const it = [...a]
               const evts = [...events]
-              yield* Effect.annotateCurrentSpan({ itemIds: it.map((_) => _[idKey]), eventCount: evts.length })
+              yield* Effect.annotateCurrentSpan({
+                "app.entity.ids": it.map((_) => _[idKey]),
+                "app.event.count": evts.length
+              })
               const items = yield* encodeMany(it).pipe(Effect.orDie)
               if (Array.isReadonlyArrayNonEmpty(items)) {
                 yield* store.batchRemove(
@@ -231,7 +237,7 @@ export function makeRepoInternal<
             }
           )
 
-          const removeById = Effect.fn("removeById", { attributes: { itemType: name } })(
+          const removeById = Effect.fn("removeById", { attributes: { "app.entity": name } })(
             function*(idOrIds: T[IdKey] | ReadonlyArray<T[IdKey]>) {
               const ids = globalThis.Array.isArray(idOrIds)
                 ? idOrIds as readonly T[IdKey][]
@@ -241,7 +247,7 @@ export function makeRepoInternal<
               }
               const { set } = yield* cms
               const eids = yield* Effect.forEach(ids, (_) => encodeIdOnly(_ as any)).pipe(Effect.orDie)
-              yield* Effect.annotateCurrentSpan({ itemIds: eids })
+              yield* Effect.annotateCurrentSpan({ "app.entity.ids": eids })
               yield* store.batchRemove(eids)
               for (const id of eids) {
                 set(id, undefined)
@@ -250,11 +256,13 @@ export function makeRepoInternal<
             }
           )
 
-          const parseMany = Effect.fn("parseMany", { attributes: { itemType: name } })(function*(items: readonly PM[]) {
-            const cm = yield* cms
-            return yield* decodeMany(items.map((_) => mapReverse(_, cm.set))).pipe(Effect.orDie)
-          })
-          const parseMany2 = Effect.fn("parseMany2", { attributes: { itemType: name } })(
+          const parseMany = Effect.fn("parseMany", { attributes: { "app.entity": name } })(
+            function*(items: readonly PM[]) {
+              const cm = yield* cms
+              return yield* decodeMany(items.map((_) => mapReverse(_, cm.set))).pipe(Effect.orDie)
+            }
+          )
+          const parseMany2 = Effect.fn("parseMany2", { attributes: { "app.entity": name } })(
             function*<A, R>(items: readonly PM[], schema: S.Codec<A, Encoded, R>) {
               const cm = yield* cms
               return yield* S.decodeEffectConcurrently(S.Array(schema))(items.map((_) => mapReverse(_, cm.set))).pipe(
@@ -332,73 +340,76 @@ export function makeRepoInternal<
                   .map(eff, (_) => NonNegativeInt(_.length))
                   .pipe(Effect.catchTag("SchemaError", (e) => Effect.die(e)))
                 : eff,
-              Effect.withSpan("Repository.query [effect-app/infra]", {
+              Effect.withSpan(`query ${name}`, {
+                kind: "client",
                 attributes: {
-                  itemType: name,
-                  "repository.model_name": name,
-                  query: { ...a, schema: a.schema ? "__SCHEMA__" : a.schema, filter: a.filter }
+                  "app.entity": name,
+                  "db.operation.name": "query",
+                  "db.collection.name": name
                 }
               }, { captureStackTrace: false })
             )
           }) as any
 
-          const validateSample = Effect.fn("validateSample", { attributes: { itemType: name } })(function*(options?: {
-            percentage?: number
-            maxItems?: number
-          }) {
-            const percentage = options?.percentage ?? 0.1 // default 10%
-            const maxItems = options?.maxItems
-
-            // 1. get all IDs with projection (bypasses main schema decode)
-            const allIds = yield* store.filter({
-              t: null as unknown as Encoded,
-              select: [idKey as keyof Encoded]
-            })
-
-            // 2. random subset
-            const shuffled = [...allIds].sort(() => Math.random() - 0.5)
-            const sampleSize = Math.min(
-              maxItems ?? Infinity,
-              Math.ceil(allIds.length * percentage)
-            )
-            const sample = shuffled.slice(0, sampleSize)
-
-            // 3. validate each item
-            const errors: ValidationError[] = []
+          const validateSample = Effect.fn("validateSample", { attributes: { "app.entity": name } })(
+            function*(options?: {
+              percentage?: number
+              maxItems?: number
+            }) {
+              const percentage = options?.percentage ?? 0.1 // default 10%
+              const maxItems = options?.maxItems
+
+              // 1. get all IDs with projection (bypasses main schema decode)
+              const allIds = yield* store.filter({
+                t: null as unknown as Encoded,
+                select: [idKey as keyof Encoded]
+              })
+
+              // 2. random subset
+              const shuffled = [...allIds].sort(() => Math.random() - 0.5)
+              const sampleSize = Math.min(
+                maxItems ?? Infinity,
+                Math.ceil(allIds.length * percentage)
+              )
+              const sample = shuffled.slice(0, sampleSize)
 
-            for (const item of sample) {
-              const id = item[idKey]
-              const rawResult = yield* store.find(id)
+              // 3. validate each item
+              const errors: ValidationError[] = []
 
-              if (Option.isNone(rawResult)) continue
+              for (const item of sample) {
+                const id = item[idKey]
+                const rawResult = yield* store.find(id)
 
-              const rawData = rawResult.value as Encoded
-              const jitMResult = mapFrom(rawData) // apply jitM
+                if (Option.isNone(rawResult)) continue
 
-              const decodeResult = yield* S.decodeEffectConcurrently(schema)(jitMResult).pipe(
-                Effect.result,
-                provideRctx
-              )
+                const rawData = rawResult.value as Encoded
+                const jitMResult = mapFrom(rawData) // apply jitM
 
-              if (Result.isFailure(decodeResult)) {
-                errors.push(
-                  ValidationError.make({
-                    id,
-                    rawData,
-                    jitMResult,
-                    error: decodeResult.failure
-                  })
+                const decodeResult = yield* S.decodeEffectConcurrently(schema)(jitMResult).pipe(
+                  Effect.result,
+                  provideRctx
                 )
+
+                if (Result.isFailure(decodeResult)) {
+                  errors.push(
+                    ValidationError.make({
+                      id,
+                      rawData,
+                      jitMResult,
+                      error: decodeResult.failure
+                    })
+                  )
+                }
               }
-            }
 
-            return ValidationResult.make({
-              total: NonNegativeInt(allIds.length),
-              sampled: NonNegativeInt(sample.length),
-              valid: NonNegativeInt(sample.length - errors.length),
-              errors
-            })
-          })
+              return ValidationResult.make({
+                total: NonNegativeInt(allIds.length),
+                sampled: NonNegativeInt(sample.length),
+                valid: NonNegativeInt(sample.length - errors.length),
+                errors
+              })
+            }
+          )
 
           const r = {
             changeFeed,
@@ -450,7 +461,7 @@ export function makeRepoInternal<
                 // },
                 save: (...xes: any[]) =>
                   Effect.flatMap(encMany(xes), (_) => saveAllE(_)).pipe(
-                    Effect.withSpan("mapped.save", { attributes: { itemType: name } }, { captureStackTrace: false })
+                    Effect.withSpan("mapped.save", { attributes: { "app.entity": name } }, { captureStackTrace: false })
                   )
               }
             }
@@ -522,7 +533,7 @@ export function makeStore<Encoded extends FieldValues>() {
               .pipe(
                 Effect.flatMap(Effect.forEach(encodeToEncoded())),
                 setupRequestContextFromCurrent("Repository.makeInitial [effect-app/infra]", {
-                  attributes: { "repository.model_name": name }
+                  attributes: { "app.entity": name }
                 })
               )
             : undefined,

package/src/QueueMaker/SQLQueue.ts

@@ -8,6 +8,7 @@ import { pretty } from "effect-app/utils"
 import { SqlClient } from "effect/unstable/sql"
 import { SQLModel } from "../adapters/SQL.js"
 import { InfraLogger } from "../logger.js"
+import { messagingSpanArgs } from "../otel.js"
 
 export const QueueId = S.Finite.pipe(S.brand("QueueId"))
 export type QueueId = typeof QueueId.Type
@@ -101,10 +102,20 @@ export const makeSQLQueue = Effect.fnUntraced(function*<
     })
   }
   const queue = {
-    publish: Effect.fn("queue.publish: " + queueName, { kind: "producer" })(function*(
+    publish: Effect.fn(`publish ${queueName}`, {
+      kind: "producer",
+      attributes: {
+        "messaging.system": "sql",
+        "messaging.operation.name": "publish",
+        "messaging.destination.name": queueName
+      }
+    })(function*(
       ...messages: NonEmptyReadonlyArray<Evt>
     ) {
-      yield* Effect.annotateCurrentSpan({ "message_tags": messages.map((_) => _._tag) })
+      yield* Effect.annotateCurrentSpan({
+        "messaging.batch.message_count": messages.length,
+        "messaging.message.types": messages.map((_) => _._tag)
+      })
       const requestContext = yield* getRequestContext
       yield* Effect.forEach(messages, (m) => q.offer(m, requestContext), { discard: true })
     }),
@@ -120,21 +131,26 @@ export const makeSQLQueue = Effect.fnUntraced(function*<
             Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
             Effect.andThen(handleEvent(body)),
             silenceAndReportError,
-            (_) =>
-              setupRequestContextWithCustomSpan(
+            (_) => {
+              const args = messagingSpanArgs({
+                operation: "process",
+                system: "sql",
+                destination: queueDrainName,
+                messageId: body.id,
+                conversationId: sessionId,
+                extra: { "messaging.message.type": body._tag, "messaging.message.body": body }
+              }, "consumer")
+              return setupRequestContextWithCustomSpan(
                 _,
                 meta,
-                `queue.drain: ${queueDrainName}.${body._tag}`,
+                args.name,
                 {
                   captureStackTrace: false,
-                  kind: "consumer",
-                  attributes: {
-                    "queue.name": queueDrainName,
-                    "queue.sessionId": sessionId,
-                    "queue.input": body
-                  }
+                  kind: args.kind,
+                  attributes: args.attributes
                 }
               )
+            }
           )
         if (meta.span) {
           effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
@@ -142,8 +158,14 @@ export const makeSQLQueue = Effect.fnUntraced(function*<
         return yield* effect
       })
 
-      return Effect.fn(`queue.drain: ${queueDrainName}`, {
-        attributes: { "queue.type": "sql", "queue.name": queueDrainName, "queue.sessionId": sessionId }
+      return Effect.fn(`receive ${queueDrainName}`, {
+        kind: "consumer",
+        attributes: {
+          "messaging.system": "sql",
+          "messaging.operation.name": "receive",
+          "messaging.destination.name": queueDrainName,
+          ...(sessionId !== undefined && { "messaging.message.conversation_id": sessionId })
+        }
       })(function*() {
         const x = yield* q.take
         yield* processMessage(x).pipe(

package/src/QueueMaker/memQueue.ts

@@ -5,6 +5,7 @@ import * as Q from "effect/Queue"
 import { MemQueue } from "../adapters/memQueue.js"
 import { getRequestContext, setupRequestContextWithCustomSpan } from "../api/setupRequest.js"
 import { InfraLogger } from "../logger.js"
+import { messagingSpanArgs } from "../otel.js"
 import { reportNonInterruptedFailure, reportNonInterruptedFailureCause } from "./errors.js"
 import { QueueMeta } from "./service.js"
 
@@ -32,10 +33,20 @@ export const makeMemQueue = Effect.fnUntraced(function*<
   const parseDrain = flow(S.decodeUnknownEffectConcurrently(drainWJson), Effect.orDie)
 
   const queue = {
-    publish: Effect.fn("queue.publish: " + queueName, { kind: "producer" })(function*(
+    publish: Effect.fn(`publish ${queueName}`, {
+      kind: "producer",
+      attributes: {
+        "messaging.system": "memory",
+        "messaging.operation.name": "publish",
+        "messaging.destination.name": queueName
+      }
+    })(function*(
       ...messages: NonEmptyReadonlyArray<Evt>
     ) {
-      yield* Effect.annotateCurrentSpan({ "message_tags": messages.map((_) => _._tag) })
+      yield* Effect.annotateCurrentSpan({
+        "messaging.batch.message_count": messages.length,
+        "messaging.message.types": 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(
@@ -63,29 +74,40 @@ export const makeMemQueue = Effect.fnUntraced(function*<
             Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
             Effect.andThen(handleEvent(body)),
             silenceAndReportError,
-            (_) =>
-              setupRequestContextWithCustomSpan(
+            (_) => {
+              const args = messagingSpanArgs({
+                operation: "process",
+                system: "memory",
+                destination: queueDrainName,
+                messageId: body.id,
+                conversationId: sessionId,
+                extra: { "messaging.message.type": body._tag, "messaging.message.body": body }
+              }, "consumer")
+              return setupRequestContextWithCustomSpan(
                 _,
                 meta,
-                `queue.drain: ${queueDrainName}.${body._tag}`,
+                args.name,
                 {
                   captureStackTrace: false,
-                  kind: "consumer",
-                  attributes: {
-                    "queue.name": queueDrainName,
-                    "queue.sessionId": sessionId,
-                    "queue.input": body
-                  }
+                  kind: args.kind,
+                  attributes: args.attributes
                 }
               )
+            }
           )
         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 }
+      return Effect.fn(`receive ${queueDrainName}`, {
+        kind: "consumer",
+        attributes: {
+          "messaging.system": "memory",
+          "messaging.operation.name": "receive",
+          "messaging.destination.name": queueDrainName,
+          ...(sessionId !== undefined && { "messaging.message.conversation_id": sessionId })
+        }
       })(function*() {
         const x = yield* Q.take(qDrain)
         const exit = yield* processMessage(x).pipe(

package/src/QueueMaker/sbqueue.ts

@@ -5,6 +5,7 @@ import { pretty } from "effect-app/utils"
 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 { QueueMeta } from "./service.js"
 
@@ -52,21 +53,26 @@ export function makeServiceBusQueue<
               Effect.orDie,
               // we silenceAndReportError here, so that the error is reported, and moves into the Exit.
               silenceAndReportError,
-              (_) =>
-                setupRequestContextWithCustomSpan(
+              (_) => {
+                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,
-                  `queue.drain: ${receiver.name}${sessionId ? `#${sessionId}` : ""}.${body._tag}`,
+                  args.name,
                   {
                     captureStackTrace: false,
-                    kind: "consumer",
-                    attributes: {
-                      "queue.name": receiver.name,
-                      "queue.sessionId": sessionId,
-                      "queue.input": body
-                    }
+                    kind: args.kind,
+                    attributes: args.attributes
                   }
                 )
+              }
             )
           if (meta.span) {
             effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
@@ -84,10 +90,18 @@ export function makeServiceBusQueue<
           .pipe(Effect.andThen(Effect.never))
       },
 
-      publish: Effect.fn("queue.publish: " + sender.name, {
-        kind: "producer"
+      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({ "message_tags": messages.map((_) => _._tag) })
+        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(

package/src/RequestContext.ts

@@ -34,16 +34,16 @@ export class RequestContext extends S.Opaque<
 }
 
 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