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

package/src/Store/SQL.ts

@@ -7,6 +7,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 { type DbSystem, 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 { buildWhereSQLQuery, logQuery, type SQLDialect, sqliteDialect } from "./SQL/query.js"
@@ -50,7 +51,7 @@ const parseSelectRow = (
   return result
 }
 
-function makeSQLStoreInt(dialect: SQLDialect, jsonColumnType: string) {
+function makeSQLStoreInt(system: DbSystem, dialect: SQLDialect, jsonColumnType: string) {
   return Effect.fnUntraced(function*({ prefix }: StorageConfig) {
     const sql = yield* SqlClient.SqlClient
     return {
@@ -175,25 +176,28 @@ function makeSQLStoreInt(dialect: SQLDialect, jsonColumnType: string) {
           seedNamespace: (ns) => seedNamespace(ns),
 
           all: resolveNamespace.pipe(
-            Effect.flatMap((ns) =>
-              exec(`SELECT id, _etag, data FROM "${tableName}" WHERE _namespace = ?`, [ns])
+            Effect.flatMap((ns) => {
+              const sqlText = `SELECT id, _etag, data FROM "${tableName}" WHERE _namespace = ?`
+              return exec(sqlText, [ns])
                 .pipe(
                   Effect.map((rows) => (rows as any[]).map((r) => parseRow<Encoded>(r, idKey, defaultValues))),
-                  Effect.withSpan("SQL.all [effect-app/infra/Store]", {
-                    attributes: {
-                      "repository.table_name": tableName,
-                      "repository.model_name": name,
-                      "repository.namespace": ns
-                    }
-                  }, { captureStackTrace: false })
+                  withDbSpan({
+                    operation: "all",
+                    system,
+                    collection: tableName,
+                    namespace: ns,
+                    entity: name,
+                    query: sqlText
+                  })
                 )
-            )
+            })
           ),
 
           find: (id) =>
             resolveNamespace.pipe(
-              Effect.flatMap((ns) =>
-                exec(`SELECT id, _etag, data FROM "${tableName}" WHERE id = ? AND _namespace = ?`, [id, ns])
+              Effect.flatMap((ns) => {
+                const sqlText = `SELECT id, _etag, data FROM "${tableName}" WHERE id = ? AND _namespace = ?`
+                return exec(sqlText, [id, ns])
                   .pipe(
                     Effect.map((rows) => {
                       const row = (rows as any[])[0]
@@ -201,11 +205,17 @@ function makeSQLStoreInt(dialect: SQLDialect, jsonColumnType: string) {
                         ? Option.some(parseRow<Encoded>(row, idKey, defaultValues))
                         : Option.none()
                     }),
-                    Effect.withSpan("SQL.find [effect-app/infra/Store]", {
-                      attributes: { "repository.table_name": tableName, "repository.model_name": name, id }
-                    }, { captureStackTrace: false })
+                    withDbSpan({
+                      operation: "find",
+                      system,
+                      collection: tableName,
+                      namespace: ns,
+                      entity: name,
+                      query: sqlText,
+                      extra: { "app.entity.id": id }
+                    })
                   )
-              )
+              })
             ),
 
           filter: <U extends keyof Encoded = never>(f: FilterArgs<Encoded, U>) => {
@@ -260,6 +270,7 @@ function makeSQLStoreInt(dialect: SQLDialect, jsonColumnType: string) {
                     .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) => {
@@ -279,9 +290,13 @@ function makeSQLStoreInt(dialect: SQLDialect, jsonColumnType: string) {
                           })
                         )
                       ),
-                      Effect.withSpan("SQL.filter [effect-app/infra/Store]", {
-                        attributes: { "repository.table_name": tableName, "repository.model_name": name }
-                      }, { captureStackTrace: false })
+                      withDbSpan({
+                        operation: "filter",
+                        system,
+                        collection: tableName,
+                        namespace: ns,
+                        entity: name
+                      })
                     )
                 ))
           },
@@ -289,52 +304,71 @@ function makeSQLStoreInt(dialect: SQLDialect, jsonColumnType: string) {
           set: (e) =>
             resolveNamespace.pipe(Effect.flatMap((ns) =>
               setInternal(e, ns).pipe(
-                Effect.withSpan("SQL.set [effect-app/infra/Store]", {
-                  attributes: { "repository.table_name": tableName, "repository.model_name": name, id: e[idKey] }
-                }, { captureStackTrace: false })
+                withDbSpan({
+                  operation: "set",
+                  system,
+                  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("SQL.batchSet [effect-app/infra/Store]", {
-                  attributes: { "repository.table_name": tableName, "repository.model_name": name }
-                }, { captureStackTrace: false })
+                withDbSpan({
+                  operation: "batchSet",
+                  system,
+                  collection: tableName,
+                  namespace: ns,
+                  entity: name
+                })
               )
             )),
 
           bulkSet: (items) =>
             resolveNamespace.pipe(Effect.flatMap((ns) =>
               bulkSetInternal(items, ns).pipe(
-                Effect.withSpan("SQL.bulkSet [effect-app/infra/Store]", {
-                  attributes: { "repository.table_name": tableName, "repository.model_name": name }
-                }, { captureStackTrace: false })
+                withDbSpan({
+                  operation: "bulkSet",
+                  system,
+                  collection: tableName,
+                  namespace: ns,
+                  entity: name
+                })
               )
             )),
 
           batchRemove: (ids) => {
             const placeholders = ids.map(() => "?").join(", ")
-            return resolveNamespace.pipe(Effect.flatMap((ns) =>
-              exec(
-                `DELETE FROM "${tableName}" WHERE id IN (${placeholders}) AND _namespace = ?`,
-                [...ids, ns]
-              )
+            return resolveNamespace.pipe(Effect.flatMap((ns) => {
+              const sqlText = `DELETE FROM "${tableName}" WHERE id IN (${placeholders}) AND _namespace = ?`
+              return exec(sqlText, [...ids, ns])
                 .pipe(
                   Effect.asVoid,
-                  Effect.withSpan("SQL.batchRemove [effect-app/infra/Store]", {
-                    attributes: { "repository.table_name": tableName, "repository.model_name": name }
-                  }, { captureStackTrace: false })
+                  withDbSpan({
+                    operation: "batchRemove",
+                    system,
+                    collection: tableName,
+                    namespace: ns,
+                    entity: name,
+                    query: sqlText
+                  })
                 )
-            ))
+            }))
           },
 
           queryRaw: (query) =>
             s.all.pipe(
               Effect.map(query.memory),
-              Effect.withSpan("SQL.queryRaw [effect-app/infra/Store]", {
-                attributes: { "repository.table_name": tableName, "repository.model_name": name }
-              }, { captureStackTrace: false })
+              withDbSpan({
+                operation: "queryRaw",
+                system,
+                collection: tableName,
+                entity: name
+              })
             )
         }
 
@@ -487,24 +521,27 @@ function makeSQLiteStorePerNs(
       const s: Store<IdKey, Encoded> = {
         seedNamespace: (ns) => seedNamespace(ns),
 
-        all: resolveNamespace.pipe(Effect.flatMap((ns) =>
-          exec(ns, `SELECT id, _etag, data FROM "${tableName}"`)
+        all: resolveNamespace.pipe(Effect.flatMap((ns) => {
+          const sqlText = `SELECT id, _etag, data FROM "${tableName}"`
+          return exec(ns, sqlText)
             .pipe(
               Effect.map((rows) => (rows as any[]).map((r) => parseRow<Encoded>(r, idKey, defaultValues))),
-              Effect.withSpan("SQLite.all [effect-app/infra/Store]", {
-                attributes: {
-                  "repository.table_name": tableName,
-                  "repository.model_name": name,
-                  "repository.namespace": ns
-                }
-              }, { captureStackTrace: false })
+              withDbSpan({
+                operation: "all",
+                system: "sqlite",
+                collection: tableName,
+                namespace: ns,
+                entity: name,
+                query: sqlText
+              })
             )
-        )),
+        })),
 
         find: (id) =>
           resolveNamespace.pipe(
-            Effect.flatMap((ns) =>
-              exec(ns, `SELECT id, _etag, data FROM "${tableName}" WHERE id = ?`, [id])
+            Effect.flatMap((ns) => {
+              const sqlText = `SELECT id, _etag, data FROM "${tableName}" WHERE id = ?`
+              return exec(ns, sqlText, [id])
                 .pipe(
                   Effect.map((rows) => {
                     const row = (rows as any[])[0]
@@ -512,11 +549,17 @@ function makeSQLiteStorePerNs(
                       ? Option.some(parseRow<Encoded>(row, idKey, defaultValues))
                       : Option.none()
                   }),
-                  Effect.withSpan("SQLite.find [effect-app/infra/Store]", {
-                    attributes: { "repository.table_name": tableName, "repository.model_name": name, id }
-                  }, { captureStackTrace: false })
+                  withDbSpan({
+                    operation: "find",
+                    system: "sqlite",
+                    collection: tableName,
+                    namespace: ns,
+                    entity: name,
+                    query: sqlText,
+                    extra: { "app.entity.id": id }
+                  })
                 )
-            )
+            })
           ),
 
         filter: <U extends keyof Encoded = never>(f: FilterArgs<Encoded, U>) => {
@@ -550,6 +593,7 @@ function makeSQLiteStorePerNs(
                   .pipe(
                     Effect
                       .tap((q) => logQuery(q)),
+                    Effect.tap((q) => Effect.annotateCurrentSpan({ "db.query.text": q.sql })),
                     Effect.flatMap((q) =>
                       exec(ns, q.sql, q.params).pipe(
                         Effect.map((rows) => {
@@ -569,9 +613,13 @@ function makeSQLiteStorePerNs(
                         })
                       )
                     ),
-                    Effect.withSpan("SQLite.filter [effect-app/infra/Store]", {
-                      attributes: { "repository.table_name": tableName, "repository.model_name": name }
-                    }, { captureStackTrace: false })
+                    withDbSpan({
+                      operation: "filter",
+                      system: "sqlite",
+                      collection: tableName,
+                      namespace: ns,
+                      entity: name
+                    })
                   )
               ))
         },
@@ -579,53 +627,71 @@ function makeSQLiteStorePerNs(
         set: (e) =>
           resolveNamespace.pipe(Effect.flatMap((ns) =>
             setInternal(e, ns).pipe(
-              Effect.withSpan("SQLite.set [effect-app/infra/Store]", {
-                attributes: { "repository.table_name": tableName, "repository.model_name": name, id: e[idKey] }
-              }, { captureStackTrace: false })
+              withDbSpan({
+                operation: "set",
+                system: "sqlite",
+                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("SQLite.batchSet [effect-app/infra/Store]", {
-                attributes: { "repository.table_name": tableName, "repository.model_name": name }
-              }, { captureStackTrace: false })
+              withDbSpan({
+                operation: "batchSet",
+                system: "sqlite",
+                collection: tableName,
+                namespace: ns,
+                entity: name
+              })
             )
           )),
 
         bulkSet: (items) =>
           resolveNamespace.pipe(Effect.flatMap((ns) =>
             bulkSetInternal(items, ns).pipe(
-              Effect.withSpan("SQLite.bulkSet [effect-app/infra/Store]", {
-                attributes: { "repository.table_name": tableName, "repository.model_name": name }
-              }, { captureStackTrace: false })
+              withDbSpan({
+                operation: "bulkSet",
+                system: "sqlite",
+                collection: tableName,
+                namespace: ns,
+                entity: name
+              })
             )
           )),
 
         batchRemove: (ids) => {
           const placeholders = ids.map(() => "?").join(", ")
-          return resolveNamespace.pipe(Effect.flatMap((ns) =>
-            exec(
-              ns,
-              `DELETE FROM "${tableName}" WHERE id IN (${placeholders})`,
-              [...ids]
-            )
+          return resolveNamespace.pipe(Effect.flatMap((ns) => {
+            const sqlText = `DELETE FROM "${tableName}" WHERE id IN (${placeholders})`
+            return exec(ns, sqlText, [...ids])
               .pipe(
                 Effect.asVoid,
-                Effect.withSpan("SQLite.batchRemove [effect-app/infra/Store]", {
-                  attributes: { "repository.table_name": tableName, "repository.model_name": name }
-                }, { captureStackTrace: false })
+                withDbSpan({
+                  operation: "batchRemove",
+                  system: "sqlite",
+                  collection: tableName,
+                  namespace: ns,
+                  entity: name,
+                  query: sqlText
+                })
               )
-          ))
+          }))
         },
 
         queryRaw: (query) =>
           s.all.pipe(
             Effect.map(query.memory),
-            Effect.withSpan("SQLite.queryRaw [effect-app/infra/Store]", {
-              attributes: { "repository.table_name": tableName, "repository.model_name": name }
-            }, { captureStackTrace: false })
+            withDbSpan({
+              operation: "queryRaw",
+              system: "sqlite",
+              collection: tableName,
+              entity: name
+            })
           )
       }
 
@@ -664,5 +730,5 @@ export function SQLiteStoreLayer(
     )
   }
   return StoreMaker
-    .toLayer(makeSQLStoreInt(sqliteDialect, "JSON")(cfg))
+    .toLayer(makeSQLStoreInt("sqlite", sqliteDialect, "JSON")(cfg))
 }

package/src/adapters/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,
@@ -596,6 +597,7 @@ export const makeRepository = <
   readonly spanPrefix: string
   readonly idColumn: Id
   readonly versionColumn?: string | undefined
+  readonly dbSystem?: DbSystem | undefined
 }): Effect.Effect<
   {
     readonly insert: (
@@ -629,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,
@@ -650,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({
@@ -663,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({
@@ -712,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({
@@ -735,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({
@@ -755,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({
@@ -768,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
@@ -795,6 +788,7 @@ export const makeDataLoaders = <
     readonly idColumn: Id
     readonly window: Input
     readonly maxBatchSize?: number | undefined
+    readonly dbSystem?: DbSystem | undefined
   }
 ): Effect.Effect<
   {
@@ -827,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({
@@ -860,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
@@ -880,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
@@ -908,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
@@ -928,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/api/internal/events.ts

@@ -24,7 +24,7 @@ export const makeSSE = <A extends { id: any }, SI, SRD, SRE>(
         Effect
           .gen(function*() {
             const ns = yield* storeId
-            yield* Effect.annotateCurrentSpan({ connectionId: id.toString() })
+            yield* Effect.annotateCurrentSpan({ "network.connection.id": id.toString() })
             yield* Effect.logInfo("$ start listening to events, id: " + id.toString() + ", ns: " + ns)
             yield* Effect.addFinalizer(() =>
               Effect.logInfo("$ end listening to events, id: " + id.toString() + ", ns: " + ns)

package/src/api/routing/middleware/middleware.ts

@@ -59,8 +59,8 @@ export const LoggerMiddlewareLive = Layer
       return (effect, { headers, payload, rpc }) =>
         Effect
           .annotateCurrentSpan({
-            "request.name": rpc._tag,
-            "requestInput": typeof payload === "object" && payload !== null
+            "rpc.method": rpc._tag,
+            "rpc.request.payload": typeof payload === "object" && payload !== null
               ? Object.entries(payload).reduce((prev, [key, value]: [string, unknown]) => {
                 prev[key] = key === "password"
                   ? "<redacted>"

package/src/api/routing.ts

@@ -496,7 +496,17 @@ export const makeRouter = <Live extends Layer.Layer<any, any, any> = Layer.Layer
                   )
                 }
                 let effect = (result as Effect.Effect<unknown, unknown, unknown>).pipe(
-                  Effect.withSpan(`Request.${meta.moduleName}.${resource._tag}`, {}, {
+                  Effect.withSpan(`${meta.moduleName}/${resource._tag}`, {
+                    kind: "server",
+                    attributes: {
+                      "rpc.system": "effect-app",
+                      "rpc.service": meta.moduleName,
+                      "rpc.method": resource._tag,
+                      "code.function.name": resource._tag,
+                      "code.namespace": meta.moduleName,
+                      "app.rpc.type": resource.type
+                    }
+                  }, {
                     captureStackTrace: () => handler.stack // capturing the handler stack is the main reason why we are doing the span here
                   })
                 )