effect-mongodb 0.4.1 → 0.6.0

package/src/DocumentCollection.ts

@@ -45,7 +45,7 @@ import * as Collection from "./Collection.js"
 import * as DocumentAggregationCursor from "./DocumentAggregationCursor.js"
 import * as DocumentFindCursor from "./DocumentFindCursor.js"
 import type { ModifyResult } from "./internal/modify-result.js"
-import { mongoErrorOrDie } from "./internal/mongo-error.js"
+import { mongoOperation } from "./internal/mongo-operation.js"
 import * as MongoError from "./MongoError.js"
 
 type DocumentCollectionFields = {
@@ -78,11 +78,11 @@ export const find: {
 } = F.dual(
   (args) => isDocumentCollection(args[0]),
   (collection: DocumentCollection, filter?: Filter<Document>, options?: FindOptions) =>
-    new DocumentFindCursor.DocumentFindCursorImpl(
-      {
-        cursor: collection.collection.find(filter ?? {}, options)
-      }
-    )
+    new DocumentFindCursor.DocumentFindCursorImpl({
+      collection: collection.collection,
+      filter: filter ?? {},
+      options: options ?? {}
+    })
 )
 
 export const findOne: {
@@ -104,7 +104,7 @@ export const findOne: {
     F.pipe(
       Effect.promise(() => collection.collection.findOne(filter, options)),
       Effect.map((value) => O.fromNullable(value)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "findOne")))
+      mongoOperation(errorSource(collection, "findOne"))
     )
 )
 
@@ -128,7 +128,7 @@ export const insertOne: {
 ): Effect.Effect<InsertOneResult, MongoError.MongoError> =>
   F.pipe(
     Effect.promise(() => collection.collection.insertOne(doc, options)),
-    Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "insertOne")))
+    mongoOperation(errorSource(collection, "insertOne"))
   ))
 
 export const insertMany: {
@@ -150,7 +150,7 @@ export const insertMany: {
 ): Effect.Effect<InsertManyResult, MongoError.MongoError> =>
   F.pipe(
     Effect.promise(() => collection.collection.insertMany(docs, options)),
-    Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "insertMany")))
+    mongoOperation(errorSource(collection, "insertMany"))
   ))
 
 export const deleteOne: {
@@ -171,7 +171,7 @@ export const deleteOne: {
   ): Effect.Effect<DeleteResult, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.deleteOne(filter, options)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "deleteOne")))
+      mongoOperation(errorSource(collection, "deleteOne"))
     )
 )
 
@@ -193,7 +193,7 @@ export const deleteMany: {
   ): Effect.Effect<DeleteResult, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.deleteMany(filter, options)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "deleteMany")))
+      mongoOperation(errorSource(collection, "deleteMany"))
     )
 )
 
@@ -223,7 +223,7 @@ export const updateOne: {
       Effect.promise(() =>
         collection.collection.updateOne(filter, Array.isArray(update) ? [...update] : update, options)
       ),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "updateOne")))
+      mongoOperation(errorSource(collection, "updateOne"))
     )
 )
 
@@ -253,7 +253,7 @@ export const updateMany: {
       Effect.promise(() =>
         collection.collection.updateMany(filter, Array.isArray(update) ? [...update] : update, options)
       ),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "updateMany")))
+      mongoOperation(errorSource(collection, "updateMany"))
     )
 )
 
@@ -281,7 +281,7 @@ export const replaceOne: {
   ): Effect.Effect<UpdateResult | Document, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.replaceOne(filter, replacement, options)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "replaceOne")))
+      mongoOperation(errorSource(collection, "replaceOne"))
     )
 )
 
@@ -350,9 +350,7 @@ export const findOneAndReplace: {
         }
         return O.fromNullable(value)
       }),
-      Effect.catchAllDefect(
-        mongoErrorOrDie(errorSource(collection, "findOneAndReplace"))
-      )
+      mongoOperation(errorSource(collection, "findOneAndReplace"))
     )
 )
 
@@ -427,9 +425,7 @@ export const findOneAndUpdate: {
         }
         return O.fromNullable(value)
       }),
-      Effect.catchAllDefect(
-        mongoErrorOrDie(errorSource(collection, "findOneAndUpdate"))
-      )
+      mongoOperation(errorSource(collection, "findOneAndUpdate"))
     )
 )
 
@@ -452,7 +448,7 @@ export const rename: {
     F.pipe(
       Effect.promise(() => collection.collection.rename(newName, options)),
       Effect.map((collection) => new DocumentCollectionImpl({ collection })),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "rename")))
+      mongoOperation(errorSource(collection, "rename"))
     )
 )
 
@@ -467,7 +463,7 @@ export const drop: {
   ): Effect.Effect<boolean, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.drop(options)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "drop")))
+      mongoOperation(errorSource(collection, "drop"))
     )
 )
 
@@ -489,7 +485,7 @@ export const createIndexes: {
   ): Effect.Effect<Array<string>, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.createIndexes([...indexSpecs], options)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "createIndexes")))
+      mongoOperation(errorSource(collection, "createIndexes"))
     )
 )
 
@@ -512,7 +508,7 @@ export const createIndex: {
   ): Effect.Effect<string, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.createIndex(indexSpec, options)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "createIndex")))
+      mongoOperation(errorSource(collection, "createIndex"))
     )
 )
 
@@ -535,7 +531,7 @@ export const dropIndex: {
   ): Effect.Effect<Document, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.dropIndex(indexName, options)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "dropIndex")))
+      mongoOperation(errorSource(collection, "dropIndex"))
     )
 )
 
@@ -555,7 +551,7 @@ export const dropIndexes: {
   ): Effect.Effect<boolean, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.dropIndexes(options)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "dropIndexes")))
+      mongoOperation(errorSource(collection, "dropIndexes"))
     )
 )
 
@@ -596,7 +592,7 @@ export const estimatedDocumentCount: {
   ): Effect.Effect<number, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.estimatedDocumentCount(options)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "estimatedDocumentCount")))
+      mongoOperation(errorSource(collection, "estimatedDocumentCount"))
     )
 )
 
@@ -618,7 +614,7 @@ export const countDocuments: {
   ): Effect.Effect<number, MongoError.MongoError> =>
     F.pipe(
       Effect.promise(() => collection.collection.countDocuments(filter, options)),
-      Effect.catchAllDefect(mongoErrorOrDie(errorSource(collection, "countDocuments")))
+      mongoOperation(errorSource(collection, "countDocuments"))
     )
 )
 
@@ -653,8 +649,8 @@ export const bulkWrite: {
     operations: ReadonlyArray<AnyBulkWriteOperation<Document>>,
     options?: BulkWriteOptions
   ): Effect.Effect<BulkWriteResult, MongoError.MongoError> =>
-    Effect.tryPromise(() => collection.collection.bulkWrite(operations, options)).pipe(
-      Effect.catchAll(mongoErrorOrDie(errorSource(collection, "bulkWrite")))
+    Effect.promise(() => collection.collection.bulkWrite(operations, options)).pipe(
+      mongoOperation(errorSource(collection, "bulkWrite"))
     )
 )
 
@@ -665,7 +661,7 @@ const errorSource = (
   functionName: string
 ) =>
   new MongoError.CollectionErrorSource({
-    module: DocumentCollectionImpl.name,
+    module: "DocumentCollection",
     functionName,
     db: collection.collection.dbName,
     collection: collection.collection.collectionName

package/src/DocumentFindCursor.ts

@@ -8,13 +8,15 @@ import type { Pipeable } from "effect/Pipeable"
 import { pipeArguments } from "effect/Pipeable"
 import type * as Schema from "effect/Schema"
 import * as Stream from "effect/Stream"
-import type { Document, Filter, FindCursor as MongoFindCursor, Sort, SortDirection } from "mongodb"
+import type { Collection as MongoCollection, Document, Filter, FindOptions, Sort, SortDirection } from "mongodb"
 import * as FindCursor from "./FindCursor.js"
-import { mongoErrorOrDie } from "./internal/mongo-error.js"
+import { mongoOperation, mongoStreamOperation } from "./internal/mongo-operation.js"
 import * as MongoError from "./MongoError.js"
 
 type DocumentFindCursorFields = {
-  cursor: MongoFindCursor<Document>
+  collection: MongoCollection
+  filter: Filter<Document>
+  options: FindOptions
 }
 
 export interface DocumentFindCursor extends DocumentFindCursorFields, Pipeable {
@@ -36,7 +38,7 @@ export const filter: {
 } = F.dual(
   (args) => isDocumentFindCursor(args[0]),
   (cursor: DocumentFindCursor, filter: Filter<Document>): DocumentFindCursor =>
-    new DocumentFindCursorImpl({ cursor: cursor.cursor.filter(filter) })
+    new DocumentFindCursorImpl({ ...cursor, filter })
 )
 
 export const project: {
@@ -45,7 +47,7 @@ export const project: {
 } = F.dual(
   (args) => isDocumentFindCursor(args[0]),
   (cursor: DocumentFindCursor, value: Document): DocumentFindCursor =>
-    new DocumentFindCursorImpl({ cursor: cursor.cursor.project(value) })
+    new DocumentFindCursorImpl({ ...cursor, options: { ...cursor.options, projection: value } })
 )
 
 export const sort: {
@@ -54,7 +56,10 @@ export const sort: {
 } = F.dual(
   (args) => isDocumentFindCursor(args[0]),
   (cursor: DocumentFindCursor, sort: Sort | string, direction?: SortDirection): DocumentFindCursor =>
-    new DocumentFindCursorImpl({ cursor: cursor.cursor.sort(sort, direction) })
+    new DocumentFindCursorImpl({
+      ...cursor,
+      options: { ...cursor.options, sort: FindCursor.sortOption(sort, direction) }
+    })
 )
 
 export const limit: {
@@ -63,21 +68,21 @@ export const limit: {
 } = F.dual(
   (args) => isDocumentFindCursor(args[0]),
   (cursor: DocumentFindCursor, value: number): DocumentFindCursor =>
-    new DocumentFindCursorImpl({ cursor: cursor.cursor.limit(value) })
+    new DocumentFindCursorImpl({ ...cursor, options: { ...cursor.options, limit: value } })
 )
 
 export const toArray = (cursor: DocumentFindCursor): Effect.Effect<Array<Document>, MongoError.MongoError> =>
   F.pipe(
-    Effect.promise(() => cursor.cursor.toArray()),
-    Effect.catchAllDefect(mongoErrorOrDie(errorSource(cursor, "toArray")))
+    Effect.promise(() => nativeCursor(cursor).toArray()),
+    mongoOperation(errorSource(cursor, "toArray"))
   )
 
 export const toStream = (
   cursor: DocumentFindCursor
 ): Stream.Stream<Document, MongoError.MongoError> =>
   F.pipe(
-    Stream.fromAsyncIterable(cursor.cursor, F.identity),
-    Stream.catchAll(mongoErrorOrDie(errorSource(cursor, "toStream")))
+    Stream.suspend(() => Stream.fromAsyncIterable(nativeCursor(cursor), F.identity)),
+    mongoStreamOperation(errorSource(cursor, "toStream"))
   )
 
 export const typed: {
@@ -86,14 +91,22 @@ export const typed: {
 } = F.dual((args) => isDocumentFindCursor(args[0]), <A, I = A, R = never>(
   cursor: DocumentFindCursor,
   schema: Schema.Schema<A, I, R>
-): FindCursor.FindCursor<A, I, R> => new FindCursor.FindCursorImpl<A, I, R>({ cursor: cursor.cursor, schema }))
+): FindCursor.FindCursor<A, I, R> =>
+  new FindCursor.FindCursorImpl<A, I, R>({
+    collection: cursor.collection,
+    filter: cursor.filter,
+    options: cursor.options,
+    schema
+  }))
+
+const nativeCursor = (cursor: DocumentFindCursor) => cursor.collection.find(cursor.filter, cursor.options)
 
 const isDocumentFindCursor = (x: unknown) => x instanceof DocumentFindCursorImpl
 
 const errorSource = (cursor: DocumentFindCursor, functionName: string) =>
   new MongoError.CollectionErrorSource({
-    module: DocumentFindCursorImpl.name,
+    module: "DocumentFindCursor",
     functionName,
-    db: cursor.cursor.namespace.db,
-    collection: cursor.cursor.namespace.collection ?? "NO_COLLECTION_NAME"
+    db: cursor.collection.dbName,
+    collection: cursor.collection.collectionName
   })

package/src/FindCursor.ts

@@ -11,13 +11,22 @@ import { pipeArguments } from "effect/Pipeable"
 import * as Schema from "effect/Schema"
 import * as Stream from "effect/Stream"
 import * as Tuple from "effect/Tuple"
-import type { Document, FindCursor as FindCursor_, Sort, SortDirection } from "mongodb"
+import type {
+  Collection as MongoCollection,
+  Document,
+  Filter as MongoFilter,
+  FindOptions as MongoFindOptions,
+  Sort,
+  SortDirection
+} from "mongodb"
 import type { Filter as Filter_ } from "./internal/filter.js"
-import { mongoErrorOrDie } from "./internal/mongo-error.js"
+import { mongoOperation, mongoStreamOperation } from "./internal/mongo-operation.js"
 import * as MongoError from "./MongoError.js"
 
 type FindCursorFields<A, I = A, R = never> = {
-  cursor: FindCursor_<unknown>
+  collection: MongoCollection
+  filter: MongoFilter<Document>
+  options: MongoFindOptions
   schema: Schema.Schema<A, I, R>
 }
 
@@ -44,7 +53,7 @@ export const filter: {
   <A, I extends Document, R>(
     cursor: FindCursor<A, I, R>,
     filter: Filter<I>
-  ): FindCursor<A, I, R> => new FindCursorImpl({ cursor: cursor.cursor.filter(filter), schema: cursor.schema })
+  ): FindCursor<A, I, R> => new FindCursorImpl({ ...cursor, filter })
 )
 
 export const project: {
@@ -63,7 +72,8 @@ export const project: {
     cursor: FindCursor<A, I, R>,
     newSchema: Schema.Schema<B, BI, BR>,
     value: T
-  ): FindCursor<B, BI, BR> => new FindCursorImpl({ cursor: cursor.cursor.project(value), schema: newSchema })
+  ): FindCursor<B, BI, BR> =>
+    new FindCursorImpl({ ...cursor, schema: newSchema, options: { ...cursor.options, projection: value } })
 )
 
 export const sort: {
@@ -79,7 +89,8 @@ export const sort: {
     cursor: FindCursor<A, I, R>,
     sort: Sort | string,
     direction?: SortDirection
-  ): FindCursor<A, I, R> => new FindCursorImpl({ cursor: cursor.cursor.sort(sort, direction), schema: cursor.schema })
+  ): FindCursor<A, I, R> =>
+    new FindCursorImpl({ ...cursor, options: { ...cursor.options, sort: sortOption(sort, direction) } })
 )
 
 export const limit: {
@@ -88,15 +99,15 @@ export const limit: {
 } = F.dual(
   (args) => isFindCursor(args[0]),
   <A, I, R>(cursor: FindCursor<A, I, R>, value: number): FindCursor<A, I, R> =>
-    new FindCursorImpl({ cursor: cursor.cursor.limit(value), schema: cursor.schema })
+    new FindCursorImpl({ ...cursor, options: { ...cursor.options, limit: value } })
 )
 
 export const toArray = <A, I, R>(
   cursor: FindCursor<A, I, R>
 ): Effect.Effect<Array<A>, MongoError.MongoError | ParseResult.ParseError, R> => {
   const decode = Schema.decodeUnknown(cursor.schema)
-  return Effect.promise(() => cursor.cursor.toArray()).pipe(
-    Effect.catchAllDefect(mongoErrorOrDie(errorSource(cursor, "toArray"))),
+  return Effect.promise(() => nativeCursor(cursor).toArray()).pipe(
+    mongoOperation(errorSource(cursor, "toArray")),
     Effect.flatMap(Effect.forEach((x) => decode(x)))
   )
 }
@@ -109,8 +120,8 @@ export const toArrayEither = <A, I, R>(
   R
 > => {
   const decode = Schema.decodeUnknown(cursor.schema)
-  return Effect.promise(() => cursor.cursor.toArray()).pipe(
-    Effect.catchAllDefect(mongoErrorOrDie(errorSource(cursor, "toArrayEither"))),
+  return Effect.promise(() => nativeCursor(cursor).toArray()).pipe(
+    mongoOperation(errorSource(cursor, "toArrayEither")),
     Effect.flatMap(Effect.forEach((x) =>
       F.pipe(
         decode(x),
@@ -126,8 +137,8 @@ export const toStream = <A, I, R>(
 ): Stream.Stream<A, MongoError.MongoError | ParseResult.ParseError, R> => {
   const decode = Schema.decodeUnknown(cursor.schema)
   return F.pipe(
-    Stream.fromAsyncIterable(cursor.cursor, F.identity),
-    Stream.catchAll(mongoErrorOrDie(errorSource(cursor, "toStream"))),
+    Stream.suspend(() => Stream.fromAsyncIterable(nativeCursor(cursor), F.identity)),
+    mongoStreamOperation(errorSource(cursor, "toStream")),
     Stream.mapEffect((x) => decode(x))
   )
 }
@@ -137,8 +148,8 @@ export const toStreamEither = <A, I, R>(
 ): Stream.Stream<E.Either<A, [document: unknown, error: ParseResult.ParseError]>, MongoError.MongoError, R> => {
   const decode = Schema.decodeUnknown(cursor.schema)
   return F.pipe(
-    Stream.fromAsyncIterable(cursor.cursor, F.identity),
-    Stream.catchAll(mongoErrorOrDie(errorSource(cursor, "toStreamEither"))),
+    Stream.suspend(() => Stream.fromAsyncIterable(nativeCursor(cursor), F.identity)),
+    mongoStreamOperation(errorSource(cursor, "toStreamEither")),
     Stream.mapEffect((x) =>
       F.pipe(
         // keep new line
@@ -150,12 +161,18 @@ export const toStreamEither = <A, I, R>(
   )
 }
 
+/** @internal */
+export const sortOption = (sort: Sort | string, direction?: SortDirection): Sort =>
+  typeof sort === "string" && direction !== undefined ? { [sort]: direction } : sort
+
+const nativeCursor = <A, I, R>(cursor: FindCursor<A, I, R>) => cursor.collection.find(cursor.filter, cursor.options)
+
 const isFindCursor = (x: unknown): x is FindCursor<unknown> => x instanceof FindCursorImpl
 
 const errorSource = <A, I, R>(cursor: FindCursor<A, I, R>, functionName: string) =>
   new MongoError.CollectionErrorSource({
-    module: FindCursorImpl.name,
+    module: "FindCursor",
     functionName,
-    db: cursor.cursor.namespace.db,
-    collection: cursor.cursor.namespace.collection ?? "NO_COLLECTION_NAME"
+    db: cursor.collection.dbName,
+    collection: cursor.collection.collectionName
   })

package/src/ListCollectionsCursor.ts

@@ -11,7 +11,7 @@ import type {
   CollectionInfo as MongoCollectionInfo,
   ListCollectionsCursor as MongoListCollectionsCursor
 } from "mongodb"
-import { mongoErrorOrDie } from "./internal/mongo-error.js"
+import { mongoOperation, mongoStreamOperation } from "./internal/mongo-operation.js"
 import * as MongoError from "./MongoError.js"
 
 export type NameOnlyCollectionInfo = Pick<MongoCollectionInfo, "name" | "type">
@@ -49,7 +49,7 @@ export const toArray = <T extends DefaultCollectionInfo>(
 ): Effect.Effect<Array<T>, MongoError.MongoError> =>
   F.pipe(
     Effect.promise(() => cursor.cursor.toArray()),
-    Effect.catchAllDefect(mongoErrorOrDie(errorSource(cursor, "toArray")))
+    mongoOperation(errorSource(cursor, "toArray"))
   )
 
 export const toStream = <T extends DefaultCollectionInfo>(
@@ -57,12 +57,12 @@ export const toStream = <T extends DefaultCollectionInfo>(
 ): Stream.Stream<T, MongoError.MongoError> =>
   F.pipe(
     Stream.fromAsyncIterable(cursor.cursor, F.identity),
-    Stream.catchAll(mongoErrorOrDie(errorSource(cursor, "toStream")))
+    mongoStreamOperation(errorSource(cursor, "toStream"))
   )
 
 const errorSource = (cursor: ListCollectionsCursor, functionName: string) =>
   new MongoError.CollectionErrorSource({
-    module: ListCollectionsCursorImpl.name,
+    module: "ListCollectionsCursor",
     functionName,
     db: cursor.cursor.namespace.db,
     collection: cursor.cursor.namespace.collection ?? "NO_COLLECTION_NAME"

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.6.0"
 
 export const getCurrentVersion = () => moduleVersion