effect-mongodb 0.4.1 → 0.5.0

package/src/MongoClient.ts

@@ -8,7 +8,7 @@ import type * as Scope from "effect/Scope"
 import type { DbOptions, MongoClientOptions } from "mongodb"
 import { MongoClient as MongoClient_ } from "mongodb"
 import * as Db from "./Db.js"
-import { mongoErrorOrDie } from "./internal/mongo-error.js"
+import { mongoOperation } from "./internal/mongo-operation.js"
 import * as MongoError from "./MongoError.js"
 
 export class MongoClient extends Data.TaggedClass("MongoClient")<{ client: MongoClient_ }> {}
@@ -19,7 +19,7 @@ export const connect = (
 ): Effect.Effect<MongoClient, MongoError.MongoError> =>
   Effect.promise(() => MongoClient_.connect(url, options)).pipe(
     Effect.map((client) => new MongoClient({ client })),
-    Effect.catchAllDefect(mongoErrorOrDie(errorSource(hostsFromUrl(url), "connect")))
+    mongoOperation(errorSource(hostsFromUrl(url), "connect"))
   )
 
 export const close: {
@@ -29,9 +29,7 @@ export const close: {
   (args) => isMongoClient(args[0]),
   ({ client }: MongoClient, force?: boolean): Effect.Effect<void, MongoError.MongoError> =>
     Effect.promise(() => client.close(force)).pipe(
-      Effect.catchAllDefect(
-        mongoErrorOrDie(errorSource(client.options.hosts.map((x) => x.host ?? UNKNOWN_HOST), "close"))
-      )
+      mongoOperation(errorSource(client.options.hosts.map((x) => x.host ?? UNKNOWN_HOST), "close"))
     )
 )
 

package/src/internal/mongo-operation.ts

@@ -0,0 +1,22 @@
+import * as Effect from "effect/Effect"
+import * as F from "effect/Function"
+import * as Stream from "effect/Stream"
+import type { ErrorSource, MongoError } from "../MongoError.js"
+import { mongoErrorOrDie } from "./mongo-error.js"
+import { withSpan, withSpanStream } from "./tracing.js"
+
+export const mongoOperation =
+  (source: ErrorSource) => <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E | MongoError, R> =>
+    F.pipe(
+      self,
+      Effect.catchAllDefect(mongoErrorOrDie(source)),
+      withSpan(source)
+    )
+
+export const mongoStreamOperation =
+  (source: ErrorSource) => <A, E, R>(self: Stream.Stream<A, E, R>): Stream.Stream<A, MongoError, R> =>
+    F.pipe(
+      self,
+      Stream.catchAll(mongoErrorOrDie(source)),
+      withSpanStream(source)
+    )

package/src/internal/tracing.ts

@@ -0,0 +1,47 @@
+import * as Effect from "effect/Effect"
+import * as F from "effect/Function"
+import * as Match from "effect/Match"
+import * as Stream from "effect/Stream"
+import type * as Tracer from "effect/Tracer"
+import type { ErrorSource } from "../MongoError.js"
+
+export const withSpan = (source: ErrorSource) => <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+  Effect.withSpan(self, spanName(source), spanOptions(source))
+
+export const withSpanStream =
+  (source: ErrorSource) => <A, E, R>(self: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> =>
+    Stream.withSpan(self, spanName(source), spanOptions(source))
+
+const spanName = (source: ErrorSource) => `mongodb.${source.module}.${source.functionName}`
+
+const spanOptions = (source: ErrorSource): Tracer.SpanOptions => ({
+  kind: "client",
+  captureStackTrace: false,
+  attributes: {
+    "db.system.name": "mongodb",
+    "db.operation.name": source.functionName,
+    ...sourceAttributes(source)
+  }
+})
+
+const sourceAttributes = (source: ErrorSource): Record<string, unknown> =>
+  F.pipe(
+    Match.value(source),
+    Match.tag("ClientErrorSource", (s) => serverAttributes(s.hosts)),
+    Match.tag("DbErrorSource", (s) => ({ "db.namespace": s.db })),
+    Match.tag("CollectionErrorSource", (s) => ({ "db.namespace": s.db, "db.collection.name": s.collection })),
+    Match.exhaustive
+  )
+
+const serverAttributes = (hosts: Array<string>): Record<string, unknown> => {
+  if (hosts.length !== 1) return {}
+  const [address, port] = splitHost(hosts[0])
+  return port === undefined ? { "server.address": address } : { "server.address": address, "server.port": port }
+}
+
+const splitHost = (host: string): [address: string, port: number | undefined] => {
+  const separator = host.lastIndexOf(":")
+  if (separator === -1) return [host, undefined]
+  const port = Number(host.slice(separator + 1))
+  return Number.isInteger(port) ? [host.slice(0, separator), port] : [host, undefined]
+}

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "0.4.1"
+let moduleVersion = "0.5.0"
 
 export const getCurrentVersion = () => moduleVersion