@effect/opentelemetry 0.61.0 → 4.0.0-beta.1

package/src/internal/protobuf.ts

@@ -1,219 +0,0 @@
-/**
- * Low-level protobuf wire format encoding utilities.
- *
- * Protobuf wire types:
- * - 0: Varint (int32, int64, uint32, uint64, sint32, sint64, bool, enum)
- * - 1: 64-bit (fixed64, sfixed64, double)
- * - 2: Length-delimited (string, bytes, embedded messages, packed repeated fields)
- * - 5: 32-bit (fixed32, sfixed32, float)
- *
- * @internal
- */
-
-const enum WireType {
-  Varint = 0,
-  Fixed64 = 1,
-  LengthDelimited = 2,
-  Fixed32 = 5
-}
-
-/**
- * Encodes a field tag (field number + wire type)
- */
-const encodeTag = (fieldNumber: number, wireType: WireType): number => (fieldNumber << 3) | wireType
-
-/**
- * Encodes a varint (variable-length integer)
- */
-export const encodeVarint = (value: number | bigint): Uint8Array => {
-  const bytes: Array<number> = []
-  let n = typeof value === "bigint" ? value : BigInt(value)
-  while (n > 0x7fn) {
-    bytes.push(Number(n & 0x7fn) | 0x80)
-    n >>= 7n
-  }
-  bytes.push(Number(n))
-  return new Uint8Array(bytes)
-}
-
-/**
- * Encodes a signed varint using ZigZag encoding
- */
-export const encodeSint = (value: number | bigint): Uint8Array => {
-  const n = typeof value === "bigint" ? value : BigInt(value)
-  const zigzag = (n << 1n) ^ (n >> 63n)
-  return encodeVarint(zigzag)
-}
-
-/**
- * Encodes a 64-bit fixed value (little-endian)
- */
-export const encodeFixed64 = (value: bigint): Uint8Array => {
-  const bytes = new Uint8Array(8)
-  const view = new DataView(bytes.buffer)
-  view.setBigUint64(0, value, true)
-  return bytes
-}
-
-/**
- * Encodes a 32-bit fixed value (little-endian)
- */
-export const encodeFixed32 = (value: number): Uint8Array => {
-  const bytes = new Uint8Array(4)
-  const view = new DataView(bytes.buffer)
-  view.setUint32(0, value, true)
-  return bytes
-}
-
-/**
- * Encodes a double (64-bit float, little-endian)
- */
-export const encodeDouble = (value: number): Uint8Array => {
-  const bytes = new Uint8Array(8)
-  const view = new DataView(bytes.buffer)
-  view.setFloat64(0, value, true)
-  return bytes
-}
-
-/**
- * Encodes a string to UTF-8 bytes
- */
-export const encodeString = (value: string): Uint8Array => new TextEncoder().encode(value)
-
-/**
- * Encodes bytes as a hex string to Uint8Array
- */
-export const encodeHexBytes = (hex: string): Uint8Array => {
-  const bytes = new Uint8Array(hex.length / 2)
-  for (let i = 0; i < hex.length; i += 2) {
-    bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16)
-  }
-  return bytes
-}
-
-/**
- * Concatenates multiple Uint8Arrays
- */
-export const concat = (...arrays: Array<Uint8Array>): Uint8Array => {
-  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0)
-  const result = new Uint8Array(totalLength)
-  let offset = 0
-  for (const arr of arrays) {
-    result.set(arr, offset)
-    offset += arr.length
-  }
-  return result
-}
-
-// Field encoders
-
-/**
- * Encodes a varint field
- */
-export const varintField = (fieldNumber: number, value: number | bigint): Uint8Array =>
-  concat(
-    encodeVarint(encodeTag(fieldNumber, WireType.Varint)),
-    encodeVarint(value)
-  )
-
-/**
- * Encodes a sint field (ZigZag encoded)
- */
-export const sintField = (fieldNumber: number, value: number | bigint): Uint8Array =>
-  concat(
-    encodeVarint(encodeTag(fieldNumber, WireType.Varint)),
-    encodeSint(value)
-  )
-
-/**
- * Encodes a bool field
- */
-export const boolField = (fieldNumber: number, value: boolean): Uint8Array => varintField(fieldNumber, value ? 1 : 0)
-
-/**
- * Encodes a fixed64 field
- */
-export const fixed64Field = (fieldNumber: number, value: bigint): Uint8Array =>
-  concat(
-    encodeVarint(encodeTag(fieldNumber, WireType.Fixed64)),
-    encodeFixed64(value)
-  )
-
-/**
- * Encodes a fixed32 field
- */
-export const fixed32Field = (fieldNumber: number, value: number): Uint8Array =>
-  concat(
-    encodeVarint(encodeTag(fieldNumber, WireType.Fixed32)),
-    encodeFixed32(value)
-  )
-
-/**
- * Encodes a double field
- */
-export const doubleField = (fieldNumber: number, value: number): Uint8Array =>
-  concat(
-    encodeVarint(encodeTag(fieldNumber, WireType.Fixed64)),
-    encodeDouble(value)
-  )
-
-/**
- * Encodes a length-delimited field (bytes, string, embedded message)
- */
-export const lengthDelimitedField = (fieldNumber: number, value: Uint8Array): Uint8Array =>
-  concat(
-    encodeVarint(encodeTag(fieldNumber, WireType.LengthDelimited)),
-    encodeVarint(value.length),
-    value
-  )
-
-/**
- * Encodes a string field
- */
-export const stringField = (fieldNumber: number, value: string): Uint8Array =>
-  lengthDelimitedField(fieldNumber, encodeString(value))
-
-/**
- * Encodes a bytes field from hex string
- */
-export const bytesFieldFromHex = (fieldNumber: number, hex: string): Uint8Array =>
-  lengthDelimitedField(fieldNumber, encodeHexBytes(hex))
-
-/**
- * Encodes an embedded message field
- */
-export const messageField = (fieldNumber: number, message: Uint8Array): Uint8Array =>
-  lengthDelimitedField(fieldNumber, message)
-
-/**
- * Encodes repeated fields
- */
-export const repeatedField = <T>(
-  fieldNumber: number,
-  values: ReadonlyArray<T>,
-  encode: (value: T) => Uint8Array
-): Uint8Array => concat(...values.map((v) => messageField(fieldNumber, encode(v))))
-
-/**
- * Encodes repeated varint fields (not packed)
- */
-export const repeatedVarintField = (
-  fieldNumber: number,
-  values: ReadonlyArray<number | bigint>
-): Uint8Array => concat(...values.map((v) => varintField(fieldNumber, v)))
-
-/**
- * Helper to conditionally encode an optional field
- */
-export const optionalField = <T>(
-  value: T | undefined,
-  encode: (v: T) => Uint8Array
-): Uint8Array => value !== undefined ? encode(value) : new Uint8Array(0)
-
-/**
- * Helper to conditionally encode a string field if non-empty
- */
-export const optionalStringField = (
-  fieldNumber: number,
-  value: string | undefined
-): Uint8Array => value !== undefined && value !== "" ? stringField(fieldNumber, value) : new Uint8Array(0)

package/src/internal/tracer.ts

@@ -1,448 +0,0 @@
-import * as OtelApi 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 Context from "effect/Context"
-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 Option from "effect/Option"
-import * as EffectTracer from "effect/Tracer"
-import { Resource } from "../Resource.js"
-import type { OtelTraceFlags, OtelTracer, OtelTracerProvider, OtelTraceState } from "../Tracer.js"
-import { nanosToHrTime, recordToAttributes, unknownToAttributeValue } from "./utils.js"
-
-const OtelSpanTypeId = Symbol.for("@effect/opentelemetry/Tracer/OtelSpan")
-
-const kindMap = {
-  "internal": OtelApi.SpanKind.INTERNAL,
-  "client": OtelApi.SpanKind.CLIENT,
-  "server": OtelApi.SpanKind.SERVER,
-  "producer": OtelApi.SpanKind.PRODUCER,
-  "consumer": OtelApi.SpanKind.CONSUMER
-}
-
-const getOtelParent = (tracer: OtelApi.TraceAPI, otelContext: OtelApi.Context, context: Context.Context<never>) => {
-  const active = tracer.getSpan(otelContext)
-  const otelParent = active ? active.spanContext() : undefined
-  return otelParent
-    ? Option.some(
-      EffectTracer.externalSpan({
-        spanId: otelParent.spanId,
-        traceId: otelParent.traceId,
-        sampled: (otelParent.traceFlags & 1) === 1,
-        context
-      })
-    )
-    : Option.none()
-}
-
-/** @internal */
-export class OtelSpan implements EffectTracer.Span {
-  readonly [OtelSpanTypeId]: typeof OtelSpanTypeId
-  readonly _tag = "Span"
-
-  readonly span: OtelApi.Span
-  readonly spanId: string
-  readonly traceId: string
-  readonly attributes = new Map<string, unknown>()
-  readonly sampled: boolean
-  readonly parent: Option.Option<EffectTracer.AnySpan>
-  status: EffectTracer.SpanStatus
-
-  constructor(
-    contextApi: OtelApi.ContextAPI,
-    traceApi: OtelApi.TraceAPI,
-    tracer: OtelApi.Tracer,
-    readonly name: string,
-    effectParent: Option.Option<EffectTracer.AnySpan>,
-    readonly context: Context.Context<never>,
-    readonly links: Array<EffectTracer.SpanLink>,
-    startTime: bigint,
-    readonly kind: EffectTracer.SpanKind,
-    options?: EffectTracer.SpanOptions
-  ) {
-    this[OtelSpanTypeId] = OtelSpanTypeId
-    const active = contextApi.active()
-    this.parent = effectParent._tag === "Some"
-      ? effectParent
-      : (options?.root !== true)
-      ? getOtelParent(traceApi, active, context)
-      : Option.none()
-    this.span = tracer.startSpan(
-      name,
-      {
-        startTime: nanosToHrTime(startTime),
-        links: links.length > 0
-          ? links.map((link) => ({
-            context: makeSpanContext(link.span),
-            attributes: recordToAttributes(link.attributes)
-          }))
-          : undefined as any,
-        kind: kindMap[this.kind]
-      },
-      this.parent._tag === "Some"
-        ? populateContext(active, this.parent.value, context)
-        : OtelApi.trace.deleteSpan(active)
-    )
-    const spanContext = this.span.spanContext()
-    this.spanId = spanContext.spanId
-    this.traceId = spanContext.traceId
-    this.status = {
-      _tag: "Started",
-      startTime
-    }
-    this.sampled = (spanContext.traceFlags & OtelApi.TraceFlags.SAMPLED) === OtelApi.TraceFlags.SAMPLED
-  }
-
-  attribute(key: string, value: unknown) {
-    this.span.setAttribute(key, unknownToAttributeValue(value))
-    this.attributes.set(key, value)
-  }
-
-  addLinks(links: ReadonlyArray<EffectTracer.SpanLink>): void {
-    // eslint-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: OtelApi.SpanStatusCode.OK })
-    } else {
-      if (Cause.isInterruptedOnly(exit.cause)) {
-        this.span.setStatus({
-          code: OtelApi.SpanStatusCode.OK,
-          message: Cause.pretty(exit.cause)
-        })
-        this.span.setAttribute("span.label", "⚠︎ Interrupted")
-        this.span.setAttribute("status.interrupted", true)
-      } else {
-        const firstError = Cause.prettyErrors(exit.cause)[0]
-        if (firstError) {
-          firstError.stack = Cause.pretty(exit.cause, { renderErrorCause: true })
-          this.span.recordException(firstError, hrTime)
-          this.span.setStatus({
-            code: OtelApi.SpanStatusCode.ERROR,
-            message: firstError.message
-          })
-        } else {
-          // empty cause means no error
-          this.span.setStatus({ code: OtelApi.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)
-    )
-  }
-}
-
-/** @internal */
-export const TracerProvider = Context.GenericTag<OtelTracerProvider, OtelApi.TracerProvider>(
-  "@effect/opentelemetry/Tracer/OtelTracerProvider"
-)
-
-/** @internal */
-export const Tracer = Context.GenericTag<OtelTracer, OtelApi.Tracer>("@effect/opentelemetry/Tracer/OtelTracer")
-
-/** @internal */
-export const make = Effect.map(Tracer, (tracer) =>
-  EffectTracer.make({
-    span(name, parent, context, links, startTime, kind, options) {
-      return new OtelSpan(
-        OtelApi.context,
-        OtelApi.trace,
-        tracer,
-        name,
-        parent,
-        context,
-        links.slice(),
-        startTime,
-        kind,
-        options
-      )
-    },
-    context(execution, fiber) {
-      const currentSpan = fiber.currentSpan
-
-      if (currentSpan === undefined) {
-        return execution()
-      }
-
-      return OtelApi.context.with(
-        populateContext(OtelApi.context.active(), currentSpan),
-        execution
-      )
-    }
-  }))
-
-/** @internal */
-export const traceFlagsTag = Context.GenericTag<OtelTraceFlags, OtelApi.TraceFlags>(
-  "@effect/opentelemetry/Tracer/OtelTraceFlags"
-)
-
-/** @internal */
-export const traceStateTag = Context.GenericTag<OtelTraceState, OtelApi.TraceState>(
-  "@effect/opentelemetry/Tracer/OtelTraceState"
-)
-
-/** @internal */
-export const makeExternalSpan = (options: {
-  readonly traceId: string
-  readonly spanId: string
-  readonly traceFlags?: number | undefined
-  readonly traceState?: string | OtelApi.TraceState | undefined
-}): EffectTracer.ExternalSpan => {
-  let context = Context.empty()
-
-  if (options.traceFlags !== undefined) {
-    context = Context.add(context, traceFlagsTag, options.traceFlags)
-  }
-
-  if (typeof options.traceState === "string") {
-    context = Option.match(createTraceState(options.traceState), {
-      onNone: () => context,
-      onSome: (traceState) => Context.add(context, traceStateTag, traceState)
-    })
-  } else if (options.traceState) {
-    context = Context.add(context, traceStateTag, options.traceState)
-  }
-
-  return {
-    _tag: "ExternalSpan",
-    traceId: options.traceId,
-    spanId: options.spanId,
-    sampled: options.traceFlags !== undefined
-      ? (options.traceFlags & OtelApi.TraceFlags.SAMPLED) === OtelApi.TraceFlags.SAMPLED
-      : true,
-    context
-  }
-}
-
-const makeOtelSpan = (span: EffectTracer.Span, clock: Clock.Clock): OtelApi.Span => {
-  const spanContext: OtelApi.SpanContext = {
-    traceId: span.traceId,
-    spanId: span.spanId,
-    traceFlags: span.sampled ? OtelApi.TraceFlags.SAMPLED : OtelApi.TraceFlags.NONE,
-    isRemote: false
-  }
-
-  let exit = Exit.void
-
-  const self: OtelApi.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: OtelApi.Attributes | undefined = undefined
-      let startTime: OtelApi.TimeInput | undefined = undefined
-      if (arguments.length === 3) {
-        attributes = arguments[1]
-        startTime = arguments[2]
-      } else if (arguments.length === 2) {
-        const arg1 = arguments[1]
-        if (isTimeInput(arg1)) {
-          startTime = arg1
-        } else {
-          attributes = arg1
-        }
-      }
-      span.event(name, convertOtelTimeInput(startTime, clock), attributes)
-      return self
-    },
-    addLink(link) {
-      span.addLinks([{
-        _tag: "SpanLink",
-        span: makeExternalSpan(link.context),
-        attributes: link.attributes ?? {}
-      }])
-      return self
-    },
-    addLinks(links) {
-      span.addLinks(links.map((link) => ({
-        _tag: "SpanLink",
-        span: makeExternalSpan(link.context),
-        attributes: link.attributes ?? {}
-      })))
-      return self
-    },
-    setStatus(status) {
-      exit = OtelApi.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 bigint1e6 = BigInt(1_000_000)
-const bigint1e9 = BigInt(1_000_000_000)
-
-/** Distinguishes TimeInput (number | Date | [number, number]) from Attributes (plain object) */
-const isTimeInput = (u: unknown): u is OtelApi.TimeInput =>
-  typeof u === "number" ||
-  u instanceof Date ||
-  (Array.isArray(u) && u.length === 2 && typeof u[0] === "number" && typeof u[1] === "number")
-
-const convertOtelTimeInput = (input: OtelApi.TimeInput | undefined, clock: Clock.Clock): bigint => {
-  if (input === undefined) {
-    return clock.unsafeCurrentTimeNanos()
-  } 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)
-}
-
-/** @internal */
-export const currentOtelSpan: Effect.Effect<OtelApi.Span, Cause.NoSuchElementException> = Effect.clockWith((clock) =>
-  Effect.map(Effect.currentSpan, (span): OtelApi.Span => {
-    if (OtelSpanTypeId in span) {
-      return (span as OtelSpan).span
-    }
-    return makeOtelSpan(span, clock)
-  })
-)
-
-/** @internal */
-export const layerGlobalProvider = Layer.sync(
-  TracerProvider,
-  () => OtelApi.trace.getTracerProvider()
-)
-
-/** @internal */
-export const layerTracer = Layer.effect(
-  Tracer,
-  Effect.flatMap(
-    Effect.zip(Resource, TracerProvider),
-    ([resource, provider]) =>
-      Effect.sync(() =>
-        provider.getTracer(
-          resource.attributes[OtelSemConv.ATTR_SERVICE_NAME] as string,
-          resource.attributes[OtelSemConv.ATTR_SERVICE_VERSION] as string
-        )
-      )
-  )
-)
-
-/** @internal */
-export const layerGlobalTracer = layerTracer.pipe(
-  Layer.provide(layerGlobalProvider)
-)
-
-/** @internal */
-export const layerGlobal = Layer.unwrapEffect(Effect.map(make, Layer.setTracer)).pipe(
-  Layer.provideMerge(layerGlobalTracer)
-)
-
-/** @internal */
-export const layerWithoutOtelTracer = Layer.unwrapEffect(Effect.map(make, Layer.setTracer))
-
-/** @internal */
-export const layer = layerWithoutOtelTracer.pipe(
-  Layer.provideMerge(layerTracer)
-)
-
-// -------------------------------------------------------------------------------------
-// utils
-// -------------------------------------------------------------------------------------
-
-const createTraceState = Option.liftThrowable(OtelApi.createTraceState)
-
-const populateContext = (
-  otelContext: OtelApi.Context,
-  span: EffectTracer.AnySpan,
-  context?: Context.Context<never>
-): OtelApi.Context =>
-  span instanceof OtelSpan ?
-    OtelApi.trace.setSpan(otelContext, span.span) :
-    OtelApi.trace.setSpanContext(otelContext, makeSpanContext(span, context))
-
-const makeSpanContext = (span: EffectTracer.AnySpan, context?: Context.Context<never>): OtelApi.SpanContext => ({
-  spanId: span.spanId,
-  traceId: span.traceId,
-  isRemote: span._tag === "ExternalSpan",
-  traceFlags: Option.getOrElse(
-    context ?
-      extractTraceTag(span, context, traceFlagsTag) :
-      Context.getOption(span.context, traceFlagsTag),
-    () => OtelApi.TraceFlags.SAMPLED
-  ),
-  traceState: Option.getOrUndefined(
-    context ?
-      extractTraceTag(span, context, traceStateTag) :
-      Context.getOption(span.context, traceStateTag)
-  ) as OtelApi.TraceState
-})
-
-const extractTraceTag = <I, S>(
-  parent: EffectTracer.AnySpan,
-  context: Context.Context<never>,
-  tag: Context.Tag<I, S>
-) =>
-  Option.orElse(
-    Context.getOption(context, tag),
-    () => Context.getOption(parent.context, tag)
-  )
-
-/** @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)))

package/src/internal/utils.ts

@@ -1,31 +0,0 @@
-import type * as OtelApi from "@opentelemetry/api"
-import type { NonEmptyReadonlyArray } from "effect/Array"
-import * as Inspectable from "effect/Inspectable"
-
-const bigint1e9 = 1_000_000_000n
-
-/** @internal */
-export const nanosToHrTime = (timestamp: bigint): OtelApi.HrTime => {
-  return [Number(timestamp / bigint1e9), Number(timestamp % bigint1e9)]
-}
-
-/** @internal */
-export const recordToAttributes = (value: Record<string, unknown>): OtelApi.Attributes =>
-  Object.entries(value).reduce((acc, [key, value]) => {
-    acc[key] = unknownToAttributeValue(value)
-    return acc
-  }, {} as OtelApi.Attributes)
-
-/** @internal */
-export const unknownToAttributeValue = (value: unknown): OtelApi.AttributeValue => {
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value
-  } else if (typeof value === "bigint") {
-    return value.toString()
-  }
-  return Inspectable.toStringUnknown(value)
-}
-
-/** @internal */
-export const isNonEmpty = <A>(a: A | ReadonlyArray<A> | undefined): a is A | NonEmptyReadonlyArray<A> =>
-  a !== undefined && !(Array.isArray(a) && a.length === 0)