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

package/src/Store/Cosmos.ts

@@ -8,6 +8,7 @@ import { OptimisticConcurrencyException } from "../errors.js"
 import { InfraLogger } from "../logger.js"
 import type { FieldValues } from "../Model/filter/types.js"
 import { type RawQuery } from "../Model/query.js"
+import { annotateCosmosResponse, withDbSpan } from "../otel.js"
 import { buildWhereCosmosQuery3, logQuery } from "./Cosmos/query.js"
 import { storeId } from "./Memory.js"
 import { type FilterArgs, type PersistenceModelType, type StorageConfig, type Store, type StoreConfig, StoreMaker } from "./service.js"
@@ -35,19 +36,21 @@ const annotateFeed = (resp: {
   requestCharge?: number
   diagnostics?: { clientSideRequestStatistics?: { totalResponsePayloadLengthInBytes?: number } }
 }) =>
-  Effect.annotateCurrentSpan({
-    "db.cosmos.request_charge": resp.requestCharge ?? 0,
-    "db.cosmos.resource_count": resp.resources.length,
-    "db.cosmos.response_bytes": respBytes(resp)
+  annotateCosmosResponse({
+    requestCharge: resp.requestCharge,
+    returnedRows: resp.resources.length,
+    responseBytes: respBytes(resp)
   })
 
 const annotateItem = (resp: {
   requestCharge?: number
+  statusCode?: number
   diagnostics?: { clientSideRequestStatistics?: { totalResponsePayloadLengthInBytes?: number } }
 }) =>
-  Effect.annotateCurrentSpan({
-    "db.cosmos.request_charge": resp.requestCharge ?? 0,
-    "db.cosmos.response_bytes": respBytes(resp)
+  annotateCosmosResponse({
+    requestCharge: resp.requestCharge,
+    statusCode: resp.statusCode,
+    responseBytes: respBytes(resp)
   })
 
 const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
@@ -137,7 +140,13 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
               )
             }),
             Effect.withLogSpan(`Cosmos.seedCheck ${name} in ${ns} [effect-app/infra/Store]`),
-            Effect.withSpan("Cosmos.seed [effect-app/infra/Store]", { attributes: { name, namespace: ns } })
+            withDbSpan({
+              operation: "seed",
+              system: "cosmosdb",
+              collection: containerId,
+              namespace: ns,
+              entity: name
+            })
           )
       }
       const seedNamespace = Effect.fn("seedNamespace")(function*(ns: string) {
@@ -251,9 +260,13 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
             return batchResult.flat() as unknown as NonEmptyReadonlyArray<Encoded>
           })
           .pipe(
-            Effect.withSpan("Cosmos.bulkSet [effect-app/infra/Store]", {
-              attributes: { "repository.container_id": containerId, "repository.model_name": name, namespace: ns }
-            }, { captureStackTrace: false })
+            withDbSpan({
+              operation: "bulkSet",
+              system: "cosmosdb",
+              collection: containerId,
+              namespace: ns,
+              entity: name
+            })
           )
 
       const bulkSet = (items: NonEmptyReadonlyArray<PM>) =>
@@ -321,14 +334,13 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                     })) as unknown as NonEmptyReadonlyArray<Encoded>
                   })))
               })
-              .pipe(Effect
-                .withSpan("Cosmos.batchSet [effect-app/infra/Store]", {
-                  attributes: {
-                    "repository.container_id": containerId,
-                    "repository.model_name": name,
-                    namespace: ns
-                  }
-                }, { captureStackTrace: false }))
+              .pipe(withDbSpan({
+                operation: "batchSet",
+                system: "cosmosdb",
+                collection: containerId,
+                namespace: ns,
+                entity: name
+              }))
           ))
       }
 
@@ -352,13 +364,14 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                     )
                   })
                   .pipe(
-                    Effect.withSpan("Cosmos.queryRaw [effect-app/infra/Store]", {
-                      attributes: {
-                        "repository.container_id": containerId,
-                        "repository.model_name": name,
-                        namespace: ns
-                      }
-                    }, { captureStackTrace: false })
+                    withDbSpan({
+                      operation: "queryRaw",
+                      system: "cosmosdb",
+                      collection: containerId,
+                      namespace: ns,
+                      entity: name,
+                      query: q.query
+                    })
                   )
               )
             ),
@@ -379,13 +392,13 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                 )
               )
               .pipe(
-                Effect.withSpan("Cosmos.batchRemove [effect-app/infra/Store]", {
-                  attributes: {
-                    "repository.container_id": containerId,
-                    "repository.model_name": name,
-                    namespace: ns
-                  }
-                }, { captureStackTrace: false })
+                withDbSpan({
+                  operation: "batchRemove",
+                  system: "cosmosdb",
+                  collection: containerId,
+                  namespace: ns,
+                  entity: name
+                })
               )
           )),
         all: Effect
@@ -408,13 +421,14 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                   return response.resources.map((_) => ({ ...defaultValues, ...mapReverseId(_) }))
                 })
                 .pipe(
-                  Effect.withSpan("Cosmos.all [effect-app/infra/Store]", {
-                    attributes: {
-                      "repository.container_id": containerId,
-                      "repository.model_name": name,
-                      namespace: ns
-                    }
-                  }, { captureStackTrace: false })
+                  withDbSpan({
+                    operation: "all",
+                    system: "cosmosdb",
+                    collection: containerId,
+                    namespace: ns,
+                    entity: name,
+                    query: q.query
+                  })
                 )
             )
           ),
@@ -472,13 +486,14 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                       return response.resources.map(({ f }) => ({ ...defaultValues, ...mapReverseId(f as any) }) as any)
                     })
                     .pipe(
-                      Effect.withSpan("Cosmos.filter [effect-app/infra/Store]", {
-                        attributes: {
-                          "repository.container_id": containerId,
-                          "repository.model_name": name,
-                          namespace: ns
-                        }
-                      }, { captureStackTrace: false })
+                      withDbSpan({
+                        operation: "filter",
+                        system: "cosmosdb",
+                        collection: containerId,
+                        namespace: ns,
+                        entity: name,
+                        query: q.query
+                      })
                     )
                 )
             )
@@ -497,16 +512,17 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                   Option.map((_) => ({ ...defaultValues, ...mapReverseId(_) }))
                 )
               })
-              .pipe(Effect
-                .withSpan("Cosmos.find [effect-app/infra/Store]", {
-                  attributes: {
-                    "repository.container_id": containerId,
-                    "repository.model_name": name,
-                    partitionValue: nsPartitionValue(ns, { [idKey]: id } as Encoded),
-                    namespace: ns,
-                    id
-                  }
-                }, { captureStackTrace: false }))
+              .pipe(withDbSpan({
+                operation: "find",
+                system: "cosmosdb",
+                collection: containerId,
+                namespace: ns,
+                entity: name,
+                extra: {
+                  "azure.cosmosdb.operation.partition_key": nsPartitionValue(ns, { [idKey]: id } as Encoded),
+                  "app.entity.id": id
+                }
+              }))
           )),
         set: (e) =>
           resolveNamespace.pipe(Effect.flatMap((ns) =>
@@ -556,15 +572,14 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                       _etag: x.etag
                     }))
                   }),
-                Effect
-                  .withSpan("Cosmos.set [effect-app/infra/Store]", {
-                    attributes: {
-                      "repository.container_id": containerId,
-                      "repository.model_name": name,
-                      namespace: ns,
-                      id: e[idKey]
-                    }
-                  }, { captureStackTrace: false })
+                withDbSpan({
+                  operation: "set",
+                  system: "cosmosdb",
+                  collection: containerId,
+                  namespace: ns,
+                  entity: name,
+                  extra: { "app.entity.id": e[idKey] }
+                })
               )
           )),
         batchSet,

package/src/Store/Disk.ts

@@ -5,6 +5,7 @@ import fs from "fs"
 
 import { Console, Effect, flow, Semaphore } from "effect-app"
 import type { FieldValues } from "../Model/filter/types.js"
+import { withDbSpan } from "../otel.js"
 import { makeMemoryStoreInt, storeId } from "./Memory.js"
 import { type PersistenceModelType, type StorageConfig, type Store, type StoreConfig, StoreMaker } from "./service.js"
 
@@ -26,42 +27,75 @@ function makeDiskStoreInt<IdKey extends keyof Encoded, Encoded extends FieldValu
       }
     }
     const file = dir + "/" + prefix + name + ".json"
+    const fileExtra = { "disk.file.path": file }
     const fsStore = {
       get: fu
         .readTextFile(file)
         .pipe(
-          Effect.withSpan("Disk.read.readFile [effect-app/infra/Store]", {}, { captureStackTrace: false }),
+          withDbSpan({
+            operation: "read.readFile",
+            system: "disk",
+            collection: name,
+            namespace,
+            entity: name,
+            extra: fileExtra
+          }),
           Effect.flatMap((x) =>
             Effect.sync(() => JSON.parse(x) as PM[]).pipe(
-              Effect.withSpan("Disk.read.parse [effect-app/infra/Store]", {}, { captureStackTrace: false })
+              withDbSpan({
+                operation: "read.parse",
+                system: "disk",
+                collection: name,
+                namespace,
+                entity: name,
+                extra: fileExtra
+              })
             )
           ),
           Effect.orDie,
-          Effect.withSpan("Disk.read [effect-app/infra/Store]", {
-            attributes: { "disk.file": file }
-          }, { captureStackTrace: false })
+          withDbSpan({
+            operation: "read",
+            system: "disk",
+            collection: name,
+            namespace,
+            entity: name,
+            extra: fileExtra
+          })
         ),
       setRaw: (v: Iterable<PM>) =>
         Effect
           .sync(() => JSON.stringify([...v], undefined, 2))
           .pipe(
-            Effect.withSpan("Disk.stringify [effect-app/infra/Store]", {
-              attributes: { "disk.file": file }
-            }, { captureStackTrace: false }),
+            withDbSpan({
+              operation: "stringify",
+              system: "disk",
+              collection: name,
+              namespace,
+              entity: name,
+              extra: fileExtra
+            }),
             Effect
               .flatMap(
                 (json) =>
                   fu
                     .writeTextFile(file, json)
-                    .pipe(Effect
-                      .withSpan("Disk.write.writeFile [effect-app/infra/Store]", {
-                        attributes: { "disk.file_size": json.length }
-                      }, { captureStackTrace: false }))
+                    .pipe(withDbSpan({
+                      operation: "write.writeFile",
+                      system: "disk",
+                      collection: name,
+                      namespace,
+                      entity: name,
+                      extra: { ...fileExtra, "disk.file.size": json.length }
+                    }))
               ),
-            Effect
-              .withSpan("Disk.write [effect-app/infra/Store]", {
-                attributes: { "disk.file": file }
-              }, { captureStackTrace: false })
+            withDbSpan({
+              operation: "write",
+              system: "disk",
+              collection: name,
+              namespace,
+              entity: name,
+              extra: fileExtra
+            })
           )
     }
 

package/src/Store/Memory.ts

@@ -4,6 +4,7 @@ import { Array, Context, Effect, flow, type NonEmptyReadonlyArray, Option, Order
 import { NonEmptyString255 } from "effect-app/Schema"
 import { InfraLogger } from "../logger.js"
 import type { FieldValues } from "../Model/filter/types.js"
+import { withDbSpan } from "../otel.js"
 import { codeFilter, codeFilter3_ } from "./codeFilter.js"
 import { type FilterArgs, type PersistenceModelType, type Store, type StoreConfig, StoreMaker } from "./service.js"
 import { makeUpdateETag } from "./utils.js"
@@ -162,38 +163,48 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
           .pipe(
             // Effect.tap(() => logQuery(query, defaultValues)),
             Effect.map(query.memory),
-            Effect.withSpan("Memory.queryRaw [effect-app/infra/Store]", {
-              attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
-            }, { captureStackTrace: false })
+            withDbSpan({
+              operation: "queryRaw",
+              system: "memory",
+              collection: modelName,
+              namespace,
+              entity: modelName
+            })
           ),
 
-      all: all.pipe(Effect.withSpan("Memory.all [effect-app/infra/Store]", {
-        attributes: {
-          modelName,
-          namespace
-        }
-      }, { captureStackTrace: false })),
+      all: all.pipe(withDbSpan({
+        operation: "all",
+        system: "memory",
+        collection: modelName,
+        namespace,
+        entity: modelName
+      })),
       find: (id) =>
         Ref
           .get(store)
           .pipe(
             Effect.map((_) => Option.fromNullishOr(_.get(id))),
-            Effect
-              .withSpan("Memory.find [effect-app/infra/Store]", {
-                attributes: {
-                  modelName,
-                  namespace
-                }
-              }, { captureStackTrace: false })
+            withDbSpan({
+              operation: "find",
+              system: "memory",
+              collection: modelName,
+              namespace,
+              entity: modelName,
+              extra: { "app.entity.id": id as unknown }
+            })
           ),
       filter: (f) =>
         all
           .pipe(
             Effect.tap(() => logQuery(f, defaultValues)),
             Effect.map(memFilter(f)),
-            Effect.withSpan("Memory.filter [effect-app/infra/Store]", {
-              attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
-            }, { captureStackTrace: false })
+            withDbSpan({
+              operation: "filter",
+              system: "memory",
+              collection: modelName,
+              namespace,
+              entity: modelName
+            })
           ),
       set: (e) =>
         s
@@ -208,10 +219,14 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
                 )
               ),
             withPermit,
-            Effect
-              .withSpan("Memory.set [effect-app/infra/Store]", {
-                attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
-              }, { captureStackTrace: false })
+            withDbSpan({
+              operation: "set",
+              system: "memory",
+              collection: modelName,
+              namespace,
+              entity: modelName,
+              extra: { "app.entity.id": e[idKey] as unknown }
+            })
           ),
       batchRemove: (items: NonEmptyReadonlyArray<Encoded[IdKey]>) =>
         pipe(
@@ -222,10 +237,13 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
               Effect.filterOrFail((_) => _.length <= 100, () => "BatchRemove: a batch may not exceed 100 items"),
               Effect.orDie,
               Effect.andThen(batchRemove),
-              Effect
-                .withSpan("Memory.batchRemove [effect-app/infra/Store]", {
-                  attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
-                }, { captureStackTrace: false })
+              withDbSpan({
+                operation: "batchRemove",
+                system: "memory",
+                collection: modelName,
+                namespace,
+                entity: modelName
+              })
             )
         ),
       batchSet: (items: readonly [PM, ...PM[]]) =>
@@ -237,18 +255,25 @@ export function makeMemoryStoreInt<IdKey extends keyof Encoded, Encoded extends
               Effect.filterOrFail((_) => _.length <= 100, () => "BatchSet: a batch may not exceed 100 items"),
               Effect.orDie,
               Effect.andThen(batchSet),
-              Effect
-                .withSpan("Memory.batchSet [effect-app/infra/Store]", {
-                  attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
-                }, { captureStackTrace: false })
+              withDbSpan({
+                operation: "batchSet",
+                system: "memory",
+                collection: modelName,
+                namespace,
+                entity: modelName
+              })
             )
         ),
       bulkSet: flow(
         batchSet,
         (_) =>
-          _.pipe(Effect.withSpan("Memory.bulkSet [effect-app/infra/Store]", {
-            attributes: { "repository.model_name": modelName, "repository.namespace": namespace }
-          }, { captureStackTrace: false }))
+          _.pipe(withDbSpan({
+            operation: "bulkSet",
+            system: "memory",
+            collection: modelName,
+            namespace,
+            entity: modelName
+          }))
       )
     }
     return s

package/src/Store/SQL/Pg.ts

@@ -6,6 +6,7 @@ import { SqlClient } from "effect/unstable/sql"
 import { OptimisticConcurrencyException } from "../../errors.js"
 import { InfraLogger } from "../../logger.js"
 import type { FieldValues } from "../../Model/filter/types.js"
+import { withDbSpan } from "../../otel.js"
 import { storeId } from "../Memory.js"
 import { type FilterArgs, type PersistenceModelType, type StorageConfig, type Store, type StoreConfig, StoreMaker } from "../service.js"
 import { makeETag } from "../utils.js"
@@ -161,25 +162,28 @@ const makePgStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
         seedNamespace: (ns) => seedNamespace(ns),
 
         all: resolveNamespace.pipe(
-          Effect.flatMap((ns) =>
-            exec(`SELECT id, _etag, data FROM "${tableName}" WHERE _namespace = $1`, [ns])
+          Effect.flatMap((ns) => {
+            const sqlText = `SELECT id, _etag, data FROM "${tableName}" WHERE _namespace = $1`
+            return exec(sqlText, [ns])
               .pipe(
                 Effect.map((rows) => (rows as any[]).map((r) => parseRow<Encoded>(r, idKey, defaultValues))),
-                Effect.withSpan("PgSQL.all [effect-app/infra/Store]", {
-                  attributes: {
-                    "repository.table_name": tableName,
-                    "repository.model_name": name,
-                    "repository.namespace": ns
-                  }
-                }, { captureStackTrace: false })
+                withDbSpan({
+                  operation: "all",
+                  system: "postgresql",
+                  collection: tableName,
+                  namespace: ns,
+                  entity: name,
+                  query: sqlText
+                })
               )
-          )
+          })
         ),
 
         find: (id) =>
           resolveNamespace.pipe(Effect
-            .flatMap((ns) =>
-              exec(`SELECT id, _etag, data FROM "${tableName}" WHERE id = $1 AND _namespace = $2`, [id, ns])
+            .flatMap((ns) => {
+              const sqlText = `SELECT id, _etag, data FROM "${tableName}" WHERE id = $1 AND _namespace = $2`
+              return exec(sqlText, [id, ns])
                 .pipe(
                   Effect.map((rows) => {
                     const row = (rows as any[])[0]
@@ -187,11 +191,17 @@ const makePgStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                       ? Option.some(parseRow<Encoded>(row, idKey, defaultValues))
                       : Option.none()
                   }),
-                  Effect.withSpan("PgSQL.find [effect-app/infra/Store]", {
-                    attributes: { "repository.table_name": tableName, "repository.model_name": name, id }
-                  }, { captureStackTrace: false })
+                  withDbSpan({
+                    operation: "find",
+                    system: "postgresql",
+                    collection: tableName,
+                    namespace: ns,
+                    entity: name,
+                    query: sqlText,
+                    extra: { "app.entity.id": id }
+                  })
                 )
-            )),
+            })),
 
         filter: <U extends keyof Encoded = never>(f: FilterArgs<Encoded, U>) => {
           const filter = f
@@ -225,6 +235,7 @@ const makePgStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
               })
               .pipe(
                 Effect.tap((q) => logQuery(q)),
+                Effect.tap((q) => Effect.annotateCurrentSpan({ "db.query.text": q.sql })),
                 Effect.flatMap((q) =>
                   exec(q.sql, q.params).pipe(
                     Effect.map((rows) => {
@@ -244,9 +255,13 @@ const makePgStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                     })
                   )
                 ),
-                Effect.withSpan("PgSQL.filter [effect-app/infra/Store]", {
-                  attributes: { "repository.table_name": tableName, "repository.model_name": name }
-                }, { captureStackTrace: false })
+                withDbSpan({
+                  operation: "filter",
+                  system: "postgresql",
+                  collection: tableName,
+                  namespace: ns,
+                  entity: name
+                })
               )
           ))
         },
@@ -254,53 +269,72 @@ const makePgStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
         set: (e) =>
           resolveNamespace.pipe(Effect.flatMap((ns) =>
             setInternal(e, ns).pipe(
-              Effect.withSpan("PgSQL.set [effect-app/infra/Store]", {
-                attributes: { "repository.table_name": tableName, "repository.model_name": name, id: e[idKey] }
-              }, { captureStackTrace: false })
+              withDbSpan({
+                operation: "set",
+                system: "postgresql",
+                collection: tableName,
+                namespace: ns,
+                entity: name,
+                extra: { "app.entity.id": e[idKey] }
+              })
             )
           )),
 
         batchSet: (items) =>
           resolveNamespace.pipe(Effect.flatMap((ns) =>
             bulkSetInternal(items, ns).pipe(
-              Effect.withSpan("PgSQL.batchSet [effect-app/infra/Store]", {
-                attributes: { "repository.table_name": tableName, "repository.model_name": name }
-              }, { captureStackTrace: false })
+              withDbSpan({
+                operation: "batchSet",
+                system: "postgresql",
+                collection: tableName,
+                namespace: ns,
+                entity: name
+              })
             )
           )),
 
         bulkSet: (items) =>
           resolveNamespace.pipe(Effect.flatMap((ns) =>
             bulkSetInternal(items, ns).pipe(
-              Effect.withSpan("PgSQL.bulkSet [effect-app/infra/Store]", {
-                attributes: { "repository.table_name": tableName, "repository.model_name": name }
-              }, { captureStackTrace: false })
+              withDbSpan({
+                operation: "bulkSet",
+                system: "postgresql",
+                collection: tableName,
+                namespace: ns,
+                entity: name
+              })
             )
           )),
 
         batchRemove: (ids) => {
           const placeholders = ids.map((_, i) => `$${i + 1}`).join(", ")
           const nsPlaceholder = `$${ids.length + 1}`
-          return resolveNamespace.pipe(Effect.flatMap((ns) =>
-            exec(
-              `DELETE FROM "${tableName}" WHERE id IN (${placeholders}) AND _namespace = ${nsPlaceholder}`,
-              [...ids, ns]
-            )
+          return resolveNamespace.pipe(Effect.flatMap((ns) => {
+            const sqlText = `DELETE FROM "${tableName}" WHERE id IN (${placeholders}) AND _namespace = ${nsPlaceholder}`
+            return exec(sqlText, [...ids, ns])
               .pipe(
                 Effect.asVoid,
-                Effect.withSpan("PgSQL.batchRemove [effect-app/infra/Store]", {
-                  attributes: { "repository.table_name": tableName, "repository.model_name": name }
-                }, { captureStackTrace: false })
+                withDbSpan({
+                  operation: "batchRemove",
+                  system: "postgresql",
+                  collection: tableName,
+                  namespace: ns,
+                  entity: name,
+                  query: sqlText
+                })
               )
-          ))
+          }))
         },
 
         queryRaw: (query) =>
           s.all.pipe(
             Effect.map(query.memory),
-            Effect.withSpan("PgSQL.queryRaw [effect-app/infra/Store]", {
-              attributes: { "repository.table_name": tableName, "repository.model_name": name }
-            }, { captureStackTrace: false })
+            withDbSpan({
+              operation: "queryRaw",
+              system: "postgresql",
+              collection: tableName,
+              entity: name
+            })
           )
       }