@effect/opentelemetry 0.60.0 → 4.0.0-beta.0

package/src/Tracer.ts

@@ -1,133 +1,302 @@
 /**
  * @since 1.0.0
  */
-import type * as Otel from "@opentelemetry/api"
-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, ParentSpan, Tracer as EffectTracer } from "effect/Tracer"
-import * as internal from "./internal/tracer.js"
-import type { Resource } from "./Resource.js"
+import * as Otel from "@opentelemetry/api"
+import * as OtelSemConv from "@opentelemetry/semantic-conventions"
+import * as Cause from "effect/Cause"
+import type * as Clock from "effect/Clock"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import { constTrue, dual } from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as Predicate from "effect/Predicate"
+import * as ServiceMap from "effect/ServiceMap"
+import * as Tracer from "effect/Tracer"
+import { recordToAttributes, unknownToAttributeValue } from "./internal/attributes.ts"
+import { Resource } from "./Resource.ts"
 
-/**
- * @since 1.0.0
- * @category constructors
- */
-export const make: Effect<EffectTracer, never, OtelTracer> = internal.make
+// =============================================================================
+// Service Definitions
+// =============================================================================
 
 /**
  * @since 1.0.0
- * @category constructors
+ * @category Services
  */
-export const makeExternalSpan: (
-  options: {
-    readonly traceId: string
-    readonly spanId: string
-    readonly traceFlags?: number | undefined
-    readonly traceState?: string | Otel.TraceState | undefined
-  }
-) => ExternalSpan = internal.makeExternalSpan
+export class OtelTracer extends ServiceMap.Service<
+  OtelTracer,
+  Otel.Tracer
+>()("@effect/opentelemetry/Tracer") {}
 
 /**
- * Get the current OpenTelemetry span.
- *
- * Works with both the official OpenTelemetry API (via `Tracer.layer`, `NodeSdk.layer`, etc.)
- * and the lightweight OTLP module (`OtlpTracer.layer`).
- *
- * When using OTLP, the returned span is a wrapper that conforms to the
- * OpenTelemetry `Span` interface.
- *
  * @since 1.0.0
- * @category accessors
+ * @category Services
  */
-export const currentOtelSpan: Effect<Otel.Span, NoSuchElementException> = internal.currentOtelSpan
+export class OtelTracerProvider extends ServiceMap.Service<
+  OtelTracerProvider,
+  Otel.TracerProvider
+>()("@effect/opentelemetry/Tracer/OtelTracerProvider") {}
 
 /**
  * @since 1.0.0
- * @category layers
+ * @category Services
  */
-export const layerWithoutOtelTracer: Layer<never, never, OtelTracer> = internal.layerWithoutOtelTracer
+export class OtelTraceFlags extends ServiceMap.Service<
+  OtelTraceFlags,
+  Otel.TraceFlags
+>()("@effect/opentelemetry/Tracer/OtelTraceFlags") {}
 
 /**
  * @since 1.0.0
- * @category layers
+ * @category Services
  */
-export const layer: Layer<OtelTracer, never, Resource | OtelTracerProvider> = internal.layer
+export class OtelTraceState extends ServiceMap.Service<
+  OtelTraceState,
+  Otel.TraceState
+>()("@effect/opentelemetry/Tracer/OtelTraceState") {}
 
-/**
- * @since 1.0.0
- * @category layers
- */
-export const layerGlobal: Layer<OtelTracer, never, Resource> = internal.layerGlobal
+// =============================================================================
+// Constructors
+// =============================================================================
 
 /**
  * @since 1.0.0
- * @category layers
+ * @category Constructors
  */
-export const layerTracer: Layer<OtelTracer, never, Resource | OtelTracerProvider> = internal.layerTracer
+export const make: Effect.Effect<Tracer.Tracer, never, OtelTracer> = Effect.map(
+  Effect.service(OtelTracer),
+  (tracer) =>
+    Tracer.make({
+      span(options) {
+        return new OtelSpan(
+          Otel.context,
+          Otel.trace,
+          tracer,
+          options
+        )
+      },
+      context(primitive, fiber) {
+        const currentSpan = fiber.currentSpan
 
-/**
- * @since 1.0.0
- * @category layers
- */
-export const layerGlobalTracer: Layer<OtelTracer, never, Resource> = internal.layerGlobalTracer
+        if (currentSpan === undefined) {
+          return primitive["~effect/Effect/evaluate"](fiber)
+        }
+
+        return Otel.context.with(
+          populateContext(Otel.context.active(), currentSpan),
+          () => primitive["~effect/Effect/evaluate"](fiber)
+        )
+      }
+    })
+)
 
 /**
  * @since 1.0.0
- * @category tags
+ * @category Constructors
  */
-export interface OtelTracerProvider {
-  readonly _: unique symbol
+export const makeExternalSpan = (options: {
+  readonly traceId: string
+  readonly spanId: string
+  readonly traceFlags?: number | undefined
+  readonly traceState?: string | Otel.TraceState | undefined
+}): Tracer.ExternalSpan => {
+  let annotations = ServiceMap.empty()
+
+  if (options.traceFlags !== undefined) {
+    annotations = ServiceMap.add(annotations, OtelTraceFlags, options.traceFlags)
+  }
+
+  if (typeof options.traceState === "string") {
+    try {
+      const traceState = Otel.createTraceState(options.traceState)
+      annotations = ServiceMap.add(annotations, OtelTraceState, traceState)
+    } catch {
+      //
+    }
+  } else if (options.traceState) {
+    annotations = ServiceMap.add(annotations, OtelTraceState, options.traceState)
+  }
+
+  return {
+    _tag: "ExternalSpan",
+    traceId: options.traceId,
+    spanId: options.spanId,
+    sampled: Predicate.isNotUndefined(options.traceFlags) ? isSampled(options.traceFlags) : true,
+    annotations
+  }
 }
 
+// =============================================================================
+// Layers
+// =============================================================================
+
 /**
  * @since 1.0.0
- * @category tags
+ * @category Layers
  */
-export const OtelTracerProvider: Tag<OtelTracerProvider, Otel.TracerProvider> = internal.TracerProvider
+export const layerGlobalProvider: Layer.Layer<OtelTracerProvider> = Layer.sync(
+  OtelTracerProvider,
+  () => Otel.trace.getTracerProvider()
+)
 
 /**
  * @since 1.0.0
- * @category tags
+ * @category Layers
  */
-export interface OtelTracer {
-  readonly _: unique symbol
-}
+export const layerTracer: Layer.Layer<OtelTracer, never, OtelTracerProvider | Resource> = Layer.effect(
+  OtelTracer,
+  Effect.gen(function*() {
+    const resource = yield* Resource
+    const provider = yield* OtelTracerProvider
+    return provider.getTracer(
+      resource.attributes[OtelSemConv.ATTR_SERVICE_NAME] as string,
+      resource.attributes[OtelSemConv.ATTR_SERVICE_VERSION] as string
+    )
+  })
+)
 
 /**
  * @since 1.0.0
- * @category tags
+ * @category Layers
  */
-export const OtelTracer: Tag<OtelTracer, Otel.Tracer> = internal.Tracer
+export const layerGlobalTracer: Layer.Layer<OtelTracer, never, Resource> = layerTracer.pipe(
+  Layer.provide(layerGlobalProvider)
+)
 
 /**
  * @since 1.0.0
- * @category tags
+ * @category Layers
  */
-export interface OtelTraceFlags {
-  readonly _: unique symbol
-}
+export const layerGlobal: Layer.Layer<OtelTracer, never, Resource> = Layer.effect(Tracer.Tracer, make).pipe(
+  Layer.provideMerge(layerGlobalTracer)
+)
 
 /**
  * @since 1.0.0
- * @category tags
+ * @category Layers
  */
-export const OtelTraceFlags: Tag<OtelTraceFlags, Otel.TraceFlags> = internal.traceFlagsTag
+export const layerWithoutOtelTracer: Layer.Layer<never, never, OtelTracer> = Layer.effect(Tracer.Tracer, make)
 
 /**
  * @since 1.0.0
- * @category tags
+ * @category Layers
  */
-export interface OtelTraceState {
-  readonly _: unique symbol
-}
+export const layer: Layer.Layer<OtelTracer, never, OtelTracerProvider | Resource> = layerWithoutOtelTracer.pipe(
+  Layer.provideMerge(layerTracer)
+)
+
+// =============================================================================
+// Utilities / Combinators
+// =============================================================================
+
+const bigint1e6 = BigInt(1_000_000)
+const bigint1e9 = BigInt(1_000_000_000)
 
 /**
+ * Get the current OpenTelemetry span.
+ *
+ * Works with both the official OpenTelemetry API (via `Tracer.layer`,
+ * `NodeSdk.layer`, etc.) and the lightweight OTLP module (`OtlpTracer.layer`).
+ *
+ * When using OTLP, the returned span is a wrapper that conforms to the
+ * OpenTelemetry `Span` interface.
+ *
  * @since 1.0.0
- * @category tags
+ * @category accessors
  */
-export const OtelTraceState: Tag<OtelTraceState, Otel.TraceState> = internal.traceStateTag
+export const currentOtelSpan: Effect.Effect<Otel.Span, Cause.NoSuchElementError> = Effect.clockWith((clock) =>
+  Effect.map(Effect.currentSpan, (span) =>
+    OtelSpanTypeId in span
+      ? (span as OtelSpan).span
+      : makeOtelSpan(span, clock))
+)
+
+const makeOtelSpan = (span: Tracer.Span, clock: Clock.Clock): Otel.Span => {
+  const spanContext: Otel.SpanContext = {
+    traceId: span.traceId,
+    spanId: span.spanId,
+    traceFlags: span.sampled ? Otel.TraceFlags.SAMPLED : Otel.TraceFlags.NONE,
+    isRemote: false
+  }
+
+  let exit = Exit.void
+
+  const self: Otel.Span = {
+    spanContext: () => spanContext,
+    setAttribute(key, value) {
+      span.attribute(key, value)
+      return self
+    },
+    setAttributes(attributes) {
+      for (const [key, value] of Object.entries(attributes)) {
+        span.attribute(key, value)
+      }
+      return self
+    },
+    addEvent(name) {
+      let attributes: Otel.Attributes | undefined = undefined
+      let startTime: Otel.TimeInput | undefined = undefined
+      if (arguments.length === 3) {
+        attributes = arguments[1]
+        startTime = arguments[2]
+      } else {
+        startTime = arguments[1]
+      }
+      span.event(name, convertOtelTimeInput(startTime, clock), attributes)
+      return self
+    },
+    addLink(link) {
+      span.addLinks([{
+        span: makeExternalSpan(link.context),
+        attributes: link.attributes ?? {}
+      }])
+      return self
+    },
+    addLinks(links) {
+      span.addLinks(links.map((link) => ({
+        span: makeExternalSpan(link.context),
+        attributes: link.attributes ?? {}
+      })))
+      return self
+    },
+    setStatus(status) {
+      exit = Otel.SpanStatusCode.ERROR
+        ? Exit.die(status.message ?? "Unknown error")
+        : Exit.void
+      return self
+    },
+    updateName: () => self,
+    end(endTime) {
+      const time = convertOtelTimeInput(endTime, clock)
+      span.end(time, exit)
+      return self
+    },
+    isRecording: constTrue,
+    recordException(exception, timeInput) {
+      const time = convertOtelTimeInput(timeInput, clock)
+      const cause = Cause.fail(exception)
+      const error = Cause.prettyErrors(cause)[0]
+      span.event(error.message, time, {
+        "exception.type": error.name,
+        "exception.message": error.message,
+        "exception.stacktrace": error.stack ?? ""
+      })
+    }
+  }
+  return self
+}
+
+const convertOtelTimeInput = (input: Otel.TimeInput | undefined, clock: Clock.Clock): bigint => {
+  if (input === undefined) {
+    return clock.currentTimeNanosUnsafe()
+  } else if (typeof input === "number") {
+    return BigInt(Math.round(input * 1_000_000))
+  } else if (input instanceof Date) {
+    return BigInt(input.getTime()) * bigint1e6
+  }
+  const [seconds, nanos] = input
+  return BigInt(seconds) * bigint1e9 + BigInt(nanos)
+}
 
 /**
  * Set the effect's parent span from the given opentelemetry `SpanContext`.
@@ -136,7 +305,7 @@ export const OtelTraceState: Tag<OtelTraceState, Otel.TraceState> = internal.tra
  * attach to a parent span.
  *
  * @since 1.0.0
- * @category propagation
+ * @category Propagation
  */
 export const withSpanContext: {
   /**
@@ -146,11 +315,11 @@ export const withSpanContext: {
    * attach to a parent span.
    *
    * @since 1.0.0
-   * @category propagation
+   * @category Propagation
    */
   (spanContext: Otel.SpanContext): <A, E, R>(
-    effect: Effect<A, E, R>
-  ) => Effect<A, E, Exclude<R, ParentSpan>>
+    self: Effect.Effect<A, E, R>
+  ) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>
   /**
    * Set the effect's parent span from the given opentelemetry `SpanContext`.
    *
@@ -158,7 +327,229 @@ export const withSpanContext: {
    * attach to a parent span.
    *
    * @since 1.0.0
-   * @category propagation
+   * @category Propagation
    */
-  <A, E, R>(effect: Effect<A, E, R>, spanContext: Otel.SpanContext): Effect<A, E, Exclude<R, ParentSpan>>
-} = internal.withSpanContext
+  <A, E, R>(self: Effect.Effect<A, E, R>, spanContext: Otel.SpanContext): Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>
+} = dual(2, <A, E, R>(
+  self: Effect.Effect<A, E, R>,
+  spanContext: Otel.SpanContext
+) => Effect.withParentSpan(self, makeExternalSpan(spanContext)))
+
+// =============================================================================
+// Internals
+// =============================================================================
+
+const OtelSpanTypeId = "~@effect/opentelemetry/Tracer/OtelSpan"
+
+const kindMap = {
+  "internal": Otel.SpanKind.INTERNAL,
+  "client": Otel.SpanKind.CLIENT,
+  "server": Otel.SpanKind.SERVER,
+  "producer": Otel.SpanKind.PRODUCER,
+  "consumer": Otel.SpanKind.CONSUMER
+}
+
+/** @internal */
+export class OtelSpan implements Tracer.Span {
+  readonly [OtelSpanTypeId]: typeof OtelSpanTypeId
+  readonly _tag = "Span"
+
+  readonly name: string
+  readonly kind: Tracer.SpanKind
+  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly links: Array<Tracer.SpanLink>
+  readonly span: Otel.Span
+  readonly spanId: string
+  readonly traceId: string
+  readonly attributes = new Map<string, unknown>()
+  readonly sampled: boolean
+  readonly parent: Tracer.AnySpan | undefined
+  status: Tracer.SpanStatus
+
+  constructor(
+    contextApi: Otel.ContextAPI,
+    traceApi: Otel.TraceAPI,
+    tracer: Otel.Tracer,
+    options: Parameters<Tracer.Tracer["span"]>[0]
+  ) {
+    this[OtelSpanTypeId] = OtelSpanTypeId
+    this.name = options.name
+    this.annotations = options.annotations
+    this.links = options.links
+    this.kind = options.kind
+    const active = contextApi.active()
+    this.parent = options.parent ?? (options?.root !== true) ?
+      getOtelParent(traceApi, active, options.annotations) :
+      undefined
+    this.span = tracer.startSpan(
+      options.name,
+      {
+        startTime: nanosToHrTime(options.startTime),
+        links: options.links.length > 0
+          ? options.links.map((link) => ({
+            context: makeSpanContext(link.span),
+            attributes: recordToAttributes(link.attributes)
+          }))
+          : undefined as any,
+        kind: kindMap[this.kind]
+      },
+      this.parent ? populateContext(active, this.parent, options.annotations) : Otel.trace.deleteSpan(active)
+    )
+    const spanContext = this.span.spanContext()
+    this.spanId = spanContext.spanId
+    this.traceId = spanContext.traceId
+    this.status = {
+      _tag: "Started",
+      startTime: options.startTime
+    }
+    this.sampled = isSampled(spanContext.traceFlags)
+  }
+
+  attribute(key: string, value: unknown) {
+    this.span.setAttribute(key, unknownToAttributeValue(value))
+    this.attributes.set(key, value)
+  }
+
+  addLinks(links: ReadonlyArray<Tracer.SpanLink>): void {
+    // oxlint-disable-next-line no-restricted-syntax
+    this.links.push(...links)
+    this.span.addLinks(links.map((link) => ({
+      context: makeSpanContext(link.span),
+      attributes: recordToAttributes(link.attributes)
+    })))
+  }
+
+  end(endTime: bigint, exit: Exit.Exit<unknown, unknown>) {
+    const hrTime = nanosToHrTime(endTime)
+    this.status = {
+      _tag: "Ended",
+      endTime,
+      exit,
+      startTime: this.status.startTime
+    }
+
+    if (exit._tag === "Success") {
+      this.span.setStatus({ code: Otel.SpanStatusCode.OK })
+    } else {
+      if (Cause.hasInterruptsOnly(exit.cause)) {
+        this.span.setStatus({
+          code: Otel.SpanStatusCode.OK,
+          message: Cause.pretty(exit.cause)
+        })
+        this.span.setAttribute("span.label", "⚠︎ Interrupted")
+        this.span.setAttribute("status.interrupted", true)
+      } else {
+        const errors = Cause.prettyErrors(exit.cause)
+        if (errors.length > 0) {
+          for (const error of errors) {
+            this.span.recordException(error, hrTime)
+          }
+          this.span.setStatus({
+            code: Otel.SpanStatusCode.ERROR,
+            message: errors[0].message
+          })
+        } else {
+          // empty cause means no error
+          this.span.setStatus({ code: Otel.SpanStatusCode.OK })
+        }
+      }
+    }
+    this.span.end(hrTime)
+  }
+
+  event(name: string, startTime: bigint, attributes?: Record<string, unknown>) {
+    this.span.addEvent(
+      name,
+      attributes ? recordToAttributes(attributes) : undefined,
+      nanosToHrTime(startTime)
+    )
+  }
+}
+
+const isSampled = (traceFlags: Otel.TraceFlags): boolean =>
+  (traceFlags & Otel.TraceFlags.SAMPLED) === Otel.TraceFlags.SAMPLED
+
+const nanosToHrTime = (timestamp: bigint): Otel.HrTime => {
+  return [Number(timestamp / bigint1e9), Number(timestamp % bigint1e9)]
+}
+
+const getOtelParent = (
+  tracer: Otel.TraceAPI,
+  context: Otel.Context,
+  annotations: ServiceMap.ServiceMap<never>
+): Tracer.AnySpan | undefined => {
+  const active = tracer.getSpan(context)
+  const otelParent = active ? active.spanContext() : undefined
+  return otelParent
+    ? Tracer.externalSpan({
+      spanId: otelParent.spanId,
+      traceId: otelParent.traceId,
+      sampled: (otelParent.traceFlags & 1) === 1,
+      annotations
+    })
+    : undefined
+}
+
+const makeSpanContext = (
+  span: Tracer.AnySpan,
+  annotations?: ServiceMap.ServiceMap<never>
+): Otel.SpanContext => {
+  const traceFlags = makeTraceFlags(span, annotations)
+  const traceState = makeTraceState(span, annotations)!
+  return ({
+    spanId: span.spanId,
+    traceId: span.traceId,
+    isRemote: span._tag === "ExternalSpan",
+    traceFlags,
+    traceState
+  })
+}
+
+const makeTraceFlags = (
+  span: Tracer.AnySpan,
+  annotations: ServiceMap.ServiceMap<never> | undefined
+): Otel.TraceFlags => {
+  let traceFlags: Otel.TraceFlags | undefined
+  if (Predicate.isNotUndefined(annotations)) {
+    traceFlags = extractTraceService(span, annotations, OtelTraceFlags)
+    if (Predicate.isUndefined(traceFlags)) {
+      traceFlags = ServiceMap.getOrUndefined(span.annotations, OtelTraceFlags)
+    }
+  }
+  return traceFlags ?? Otel.TraceFlags.SAMPLED
+}
+
+const makeTraceState = (
+  span: Tracer.AnySpan,
+  annotations: ServiceMap.ServiceMap<never> | undefined
+): Otel.TraceState | undefined => {
+  let traceState: Otel.TraceState | undefined
+  if (Predicate.isNotUndefined(annotations)) {
+    traceState = extractTraceService(span, annotations, OtelTraceState)
+    if (Predicate.isUndefined(traceState)) {
+      traceState = ServiceMap.getOrUndefined(span.annotations, OtelTraceState)
+    }
+  }
+  return traceState
+}
+
+const extractTraceService = <I, S>(
+  parent: Tracer.AnySpan,
+  annotations: ServiceMap.ServiceMap<never>,
+  service: ServiceMap.Service<I, S>
+) => {
+  const instance = ServiceMap.getOrUndefined(annotations, service)
+  if (Predicate.isNotUndefined(instance)) {
+    return instance
+  }
+  return ServiceMap.getOrUndefined(parent.annotations, service)
+}
+
+const populateContext = (
+  context: Otel.Context,
+  span: Tracer.AnySpan,
+  annotations?: ServiceMap.ServiceMap<never> | undefined
+): Otel.Context =>
+  span instanceof OtelSpan ?
+    Otel.trace.setSpan(context, span.span) :
+    Otel.trace.setSpanContext(context, makeSpanContext(span, annotations))