add Tracer.withSpanContext

.changeset/fluffy-pandas-think.md

@@ -0,0 +1,32 @@
+---
+"@effect/opentelemetry": patch
+---
+
+add Tracer.withSpanContext
+
+This api is useful for attaching a parent span to an Effect from an opentelemetry
+span outside of Effect.
+
+```typescript
+import { Effect } from "effect"
+import { Tracer } from "@effect/opentelemetry"
+import * as OtelApi from "@opentelemetry/api"
+
+await OtelApi.trace.getTracer("test").startActiveSpan(
+  "otel-span",
+  {
+    root: true
+  },
+  async (span) => {
+    try {
+      await Effect.runPromise(
+        Effect.log("inside otel parent span").pipe(
+          Tracer.withSpanContext(span.spanContext())
+        )
+      )
+    } finally {
+      span.end()
+    }
+  }
+)
+```

.changeset/nasty-lizards-bathe.md

@@ -0,0 +1,5 @@
+---
+"@effect/opentelemetry": minor
+---
+
+remove Tracer.withActiveSpan

packages/opentelemetry/src/Tracer.ts

@@ -6,7 +6,7 @@ import type { NoSuchElementException } from "effect/Cause"
 import type { Tag } from "effect/Context"
 import type { Effect } from "effect/Effect"
 import type { Layer } from "effect/Layer"
-import type { ExternalSpan, Tracer as EffectTracer } from "effect/Tracer"
+import type { ExternalSpan, ParentSpan, Tracer as EffectTracer } from "effect/Tracer"
 import * as internal from "./internal/tracer.js"
 import type { Resource } from "./Resource.js"
 
@@ -84,13 +84,22 @@ export const TraceFlags: Tag<Otel.TraceFlags, Otel.TraceFlags> = internal.traceF
 export const TraceState: Tag<Otel.TraceState, Otel.TraceState> = internal.traceStateTag
 
 /**
- * Attach the provided Effect to the current Span as reported from OpenTelemetry's
- * context propagation.
+ * Set the effect's parent span from the given opentelemetry `SpanContext`.
  *
  * This is handy when you set up OpenTelemetry outside of Effect and want to
  * attach to a parent span.
  *
  * @since 1.0.0
  * @category propagation
  */
-export const withActiveSpan: <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R> = internal.withActiveSpan
+export const withSpanContext: {
+  (
+    spanContext: Otel.SpanContext
+  ): <A, E, R>(
+    effect: Effect<A, E, R>
+  ) => Effect<A, E, Exclude<R, ParentSpan>>
+  <A, E, R>(
+    effect: Effect<A, E, R>,
+    spanContext: Otel.SpanContext
+  ): Effect<A, E, Exclude<R, ParentSpan>>
+} = internal.withSpanContext

packages/opentelemetry/src/internal/tracer.ts

@@ -3,6 +3,7 @@ import * as Cause from "effect/Cause"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import type { Exit } from "effect/Exit"
+import { dual } from "effect/Function"
 import * as Inspectable from "effect/Inspectable"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
@@ -305,12 +306,17 @@ const unknownToAttributeValue = (value: unknown): OtelApi.AttributeValue => {
   return Inspectable.toStringUnknown(value)
 }
 
-export const withActiveSpan = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-  Effect.suspend(() => {
-    const activeSpan = OtelApi.trace.getActiveSpan()
-    if (!activeSpan) {
-      return effect
-    }
-    const span = makeExternalSpan(activeSpan.spanContext())
-    return Effect.withParentSpan(effect, span)
-  })
+/** @internal */
+export const withSpanContext = dual<
+  (
+    spanContext: OtelApi.SpanContext
+  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, EffectTracer.ParentSpan>>,
+  <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+    spanContext: OtelApi.SpanContext
+  ) => Effect.Effect<A, E, Exclude<R, EffectTracer.ParentSpan>>
+>(2, <A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+  spanContext: OtelApi.SpanContext
+): Effect.Effect<A, E, Exclude<R, EffectTracer.ParentSpan>> =>
+  Effect.withParentSpan(effect, makeExternalSpan(spanContext)))

packages/opentelemetry/test/Tracer.test.ts

@@ -1,5 +1,6 @@
-import { currentOtelSpan, OtelSpan, withActiveSpan } from "@effect/opentelemetry/internal/tracer"
+import { OtelSpan } from "@effect/opentelemetry/internal/tracer"
 import * as NodeSdk from "@effect/opentelemetry/NodeSdk"
+import * as Tracer from "@effect/opentelemetry/Tracer"
 import * as it from "@effect/vitest"
 import * as OtelApi from "@opentelemetry/api"
 import { AsyncHooksContextManager } from "@opentelemetry/context-async-hooks"
@@ -24,19 +25,18 @@ describe("Tracer", () => {
     it.effect("withSpan", () =>
       Effect.provide(
         Effect.withSpan("ok")(
-          Effect.gen(function*(_) {
-            const span = yield* _(Effect.currentSpan)
+          Effect.gen(function*() {
+            const span = yield* Effect.currentSpan
             expect(span).instanceOf(OtelSpan)
           })
         ),
         TracingLive
       ))
 
     it.effect("withSpan links", () =>
-      Effect.gen(function*(_) {
-        const linkedSpan = yield* _(Effect.makeSpanScoped("B"))
-        const span = yield* _(
-          Effect.currentSpan,
+      Effect.gen(function*() {
+        const linkedSpan = yield* Effect.makeSpanScoped("B")
+        const span = yield* Effect.currentSpan.pipe(
           Effect.withSpan("A"),
           Effect.linkSpans(linkedSpan)
         )
@@ -58,8 +58,8 @@ describe("Tracer", () => {
       ))
 
     it.effect("supervisor sets context generator", () =>
-      Effect.gen(function*(_) {
-        yield* _(Effect.yieldNow())
+      Effect.gen(function*() {
+        yield* Effect.yieldNow()
         expect(OtelApi.trace.getSpan(OtelApi.context.active())).toBeDefined()
       }).pipe(
         Effect.withSpan("ok"),
@@ -69,23 +69,23 @@ describe("Tracer", () => {
     it.effect("currentOtelSpan", () =>
       Effect.provide(
         Effect.withSpan("ok")(
-          Effect.gen(function*(_) {
-            const span = yield* _(Effect.currentSpan)
-            const otelSpan = yield* _(currentOtelSpan)
+          Effect.gen(function*() {
+            const span = yield* Effect.currentSpan
+            const otelSpan = yield* Tracer.currentOtelSpan
             expect((span as OtelSpan).span).toBe(otelSpan)
           })
         ),
         TracingLive
       ))
 
-    it.scoped("withActiveSpan", () =>
+    it.scoped("withSpanContext", () =>
       Effect.gen(function*() {
         const effect = Effect.gen(function*() {
           const span = yield* Effect.currentParentSpan
           assert(span._tag === "Span")
           const parent = yield* span.parent
           return parent
-        }).pipe(Effect.withSpan("child"), withActiveSpan)
+        }).pipe(Effect.withSpan("child"))
 
         const runtime = yield* Effect.runtime()
 
@@ -95,7 +95,10 @@ describe("Tracer", () => {
             attributes: { "root": "yes" }
           }, async (span) => {
             try {
-              const parent = await Runtime.runPromise(runtime)(effect)
+              const parent = await Runtime.runPromise(runtime)(Tracer.withSpanContext(
+                effect,
+                span.spanContext()
+              ))
               const { spanId, traceId } = span.spanContext()
               expect(parent).toMatchObject({
                 spanId,
@@ -112,8 +115,8 @@ describe("Tracer", () => {
   describe("not provided", () => {
     it.effect("withSpan", () =>
       Effect.withSpan("ok")(
-        Effect.gen(function*(_) {
-          const span = yield* _(Effect.currentSpan)
+        Effect.gen(function*() {
+          const span = yield* Effect.currentSpan
           expect(span).not.instanceOf(OtelSpan)
         })
       ))