@effect/opentelemetry 4.0.0-beta.7 → 4.0.0-beta.71

package/src/Tracer.ts

@@ -1,18 +1,36 @@
 /**
- * @since 1.0.0
+ * Bridges Effect tracing into OpenTelemetry by installing an Effect `Tracer`
+ * that creates OpenTelemetry spans, records attributes, events, links, errors,
+ * and status, and keeps OpenTelemetry context active while traced effects run.
+ * Use this module when an application already has an OpenTelemetry
+ * `TracerProvider`, or when the Node and Web SDK layers should expose Effect
+ * spans to OTLP, console, or other OpenTelemetry-compatible exporters.
+ *
+ * The layer constructors wire Effect's tracer service to either the global
+ * OpenTelemetry tracer provider or an explicitly provided `OtelTracer`. This
+ * module does not create exporters or span processors by itself, so spans are
+ * exported only when the provider has been configured by the application or by
+ * the Node/Web SDK layers. Parentage is taken from Effect spans first and can
+ * also attach to the active OpenTelemetry context, while `makeExternalSpan` and
+ * `withSpanContext` are the entry points for continuing an incoming remote
+ * trace. Preserve `traceFlags` and `traceState` when building external spans;
+ * otherwise sampling defaults to sampled and trace state cannot be propagated.
+ *
+ * @since 4.0.0
  */
 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 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 Predicate from "effect/Predicate"
-import * as ServiceMap from "effect/ServiceMap"
 import * as Tracer from "effect/Tracer"
-import { recordToAttributes, unknownToAttributeValue } from "./internal/attributes.ts"
+import { nanosToHrTime, recordToAttributes, unknownToAttributeValue } from "./internal/attributes.ts"
 import { Resource } from "./Resource.ts"
 
 // =============================================================================
@@ -20,37 +38,45 @@ import { Resource } from "./Resource.ts"
 // =============================================================================
 
 /**
- * @since 1.0.0
- * @category Services
+ * Context service containing the OpenTelemetry `Tracer` used to create spans for Effect tracing.
+ *
+ * @category services
+ * @since 4.0.0
  */
-export class OtelTracer extends ServiceMap.Service<
+export class OtelTracer extends Context.Service<
   OtelTracer,
   Otel.Tracer
 >()("@effect/opentelemetry/Tracer") {}
 
 /**
- * @since 1.0.0
- * @category Services
+ * Context service containing the OpenTelemetry `TracerProvider` used to obtain tracers.
+ *
+ * @category services
+ * @since 4.0.0
  */
-export class OtelTracerProvider extends ServiceMap.Service<
+export class OtelTracerProvider extends Context.Service<
   OtelTracerProvider,
   Otel.TracerProvider
 >()("@effect/opentelemetry/Tracer/OtelTracerProvider") {}
 
 /**
- * @since 1.0.0
- * @category Services
+ * Context service containing OpenTelemetry trace flags used when constructing external span contexts.
+ *
+ * @category services
+ * @since 4.0.0
  */
-export class OtelTraceFlags extends ServiceMap.Service<
+export class OtelTraceFlags extends Context.Service<
   OtelTraceFlags,
   Otel.TraceFlags
 >()("@effect/opentelemetry/Tracer/OtelTraceFlags") {}
 
 /**
- * @since 1.0.0
- * @category Services
+ * Context service containing OpenTelemetry trace state used when constructing external span contexts.
+ *
+ * @category services
+ * @since 4.0.0
  */
-export class OtelTraceState extends ServiceMap.Service<
+export class OtelTraceState extends Context.Service<
   OtelTraceState,
   Otel.TraceState
 >()("@effect/opentelemetry/Tracer/OtelTraceState") {}
@@ -60,8 +86,10 @@ export class OtelTraceState extends ServiceMap.Service<
 // =============================================================================
 
 /**
- * @since 1.0.0
- * @category Constructors
+ * Creates an Effect `Tracer` implementation backed by the configured OpenTelemetry tracer.
+ *
+ * @category constructors
+ * @since 4.0.0
  */
 export const make: Effect.Effect<Tracer.Tracer, never, OtelTracer> = Effect.map(
   Effect.service(OtelTracer),
@@ -91,8 +119,10 @@ export const make: Effect.Effect<Tracer.Tracer, never, OtelTracer> = Effect.map(
 )
 
 /**
- * @since 1.0.0
- * @category Constructors
+ * Creates an Effect external span from an OpenTelemetry span context, preserving trace flags and trace state when provided.
+ *
+ * @category constructors
+ * @since 4.0.0
  */
 export const makeExternalSpan = (options: {
   readonly traceId: string
@@ -100,22 +130,24 @@ export const makeExternalSpan = (options: {
   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)
-  }
+  const annotations = Context.mutate(Context.empty(), (annotations) => {
+    let next = annotations
+    if (options.traceFlags !== undefined) {
+      next = Context.add(next, OtelTraceFlags, options.traceFlags)
+    }
 
-  if (typeof options.traceState === "string") {
-    try {
-      const traceState = Otel.createTraceState(options.traceState)
-      annotations = ServiceMap.add(annotations, OtelTraceState, traceState)
-    } catch {
-      //
+    if (typeof options.traceState === "string") {
+      try {
+        next = Context.add(next, OtelTraceState, Otel.createTraceState(options.traceState))
+      } catch {
+        //
+      }
+    } else if (options.traceState) {
+      next = Context.add(next, OtelTraceState, options.traceState)
     }
-  } else if (options.traceState) {
-    annotations = ServiceMap.add(annotations, OtelTraceState, options.traceState)
-  }
+
+    return next
+  })
 
   return {
     _tag: "ExternalSpan",
@@ -131,8 +163,10 @@ export const makeExternalSpan = (options: {
 // =============================================================================
 
 /**
- * @since 1.0.0
- * @category Layers
+ * Layer that provides the current global OpenTelemetry tracer provider.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layerGlobalProvider: Layer.Layer<OtelTracerProvider> = Layer.sync(
   OtelTracerProvider,
@@ -140,8 +174,10 @@ export const layerGlobalProvider: Layer.Layer<OtelTracerProvider> = Layer.sync(
 )
 
 /**
- * @since 1.0.0
- * @category Layers
+ * Layer that creates an OpenTelemetry tracer from the provided tracer provider and resource metadata.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layerTracer: Layer.Layer<OtelTracer, never, OtelTracerProvider | Resource> = Layer.effect(
   OtelTracer,
@@ -156,30 +192,48 @@ export const layerTracer: Layer.Layer<OtelTracer, never, OtelTracerProvider | Re
 )
 
 /**
- * @since 1.0.0
- * @category Layers
+ * Layer that creates an OpenTelemetry tracer from the global tracer provider and the current resource.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layerGlobalTracer: Layer.Layer<OtelTracer, never, Resource> = layerTracer.pipe(
   Layer.provide(layerGlobalProvider)
 )
 
 /**
- * @since 1.0.0
- * @category Layers
+ * Layer that installs an Effect tracer backed by the global OpenTelemetry tracer provider.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layerGlobal: Layer.Layer<OtelTracer, never, Resource> = Layer.effect(Tracer.Tracer, make).pipe(
   Layer.provideMerge(layerGlobalTracer)
 )
 
 /**
- * @since 1.0.0
- * @category Layers
+ * Layer that installs the Effect tracer using an `OtelTracer` already provided in the environment.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layerWithoutOtelTracer: Layer.Layer<never, never, OtelTracer> = Layer.effect(Tracer.Tracer, make)
 
 /**
- * @since 1.0.0
- * @category Layers
+ * Layer that creates an OpenTelemetry tracer from a provider and resource, then installs it as the Effect tracer.
+ *
+ * **When to use**
+ *
+ * Use when your application already supplies an `OtelTracerProvider` and a
+ * `Resource`, and you want Effect spans to be created by an OpenTelemetry
+ * tracer derived from those services.
+ *
+ * @see {@link layerTracer} for creating only the OpenTelemetry tracer service
+ * @see {@link layerGlobal} for installing the Effect tracer from the global provider
+ * @see {@link layerWithoutOtelTracer} for installing an already-provided `OtelTracer`
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layer: Layer.Layer<OtelTracer, never, OtelTracerProvider | Resource> = layerWithoutOtelTracer.pipe(
   Layer.provideMerge(layerTracer)
@@ -193,16 +247,17 @@ const bigint1e6 = BigInt(1_000_000)
 const bigint1e9 = BigInt(1_000_000_000)
 
 /**
- * Get the current OpenTelemetry span.
+ * Gets the current OpenTelemetry span.
  *
- * Works with both the official OpenTelemetry API (via `Tracer.layer`,
- * `NodeSdk.layer`, etc.) and the lightweight OTLP module (`OtlpTracer.layer`).
+ * **Details**
  *
- * When using OTLP, the returned span is a wrapper that conforms to the
- * OpenTelemetry `Span` interface.
+ * This accessor works with both the official OpenTelemetry API, such as
+ * `Tracer.layer` and `NodeSdk.layer`, and the lightweight OTLP module, such as
+ * `OtlpTracer.layer`. When using OTLP, the returned span is a wrapper that
+ * conforms to the OpenTelemetry `Span` interface.
  *
- * @since 1.0.0
  * @category accessors
+ * @since 4.0.0
  */
 export const currentOtelSpan: Effect.Effect<Otel.Span, Cause.NoSuchElementError> = Effect.clockWith((clock) =>
   Effect.map(Effect.currentSpan, (span) =>
@@ -299,35 +354,41 @@ const convertOtelTimeInput = (input: Otel.TimeInput | undefined, clock: Clock.Cl
 }
 
 /**
- * Set the effect's parent span from the given opentelemetry `SpanContext`.
+ * Sets an 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.
+ * **When to use**
  *
- * @since 1.0.0
- * @category Propagation
+ * Use when OpenTelemetry instrumentation outside Effect has already
+ * produced a parent span context and an effect should continue that trace.
+ *
+ * @category propagation
+ * @since 4.0.0
  */
 export const withSpanContext: {
   /**
-   * Set the effect's parent span from the given opentelemetry `SpanContext`.
+   * Sets an effect's parent span from the given OpenTelemetry `SpanContext`.
+   *
+   * **When to use**
    *
-   * This is handy when you set up OpenTelemetry outside of Effect and want to
-   * attach to a parent span.
+   * Use when OpenTelemetry instrumentation outside Effect has already
+   * produced a parent span context and an effect should continue that trace.
    *
-   * @since 1.0.0
-   * @category Propagation
+   * @category propagation
+   * @since 4.0.0
    */
   (spanContext: Otel.SpanContext): <A, E, R>(
     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`.
+   * Sets an 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.
+   * **When to use**
    *
-   * @since 1.0.0
-   * @category Propagation
+   * Use when OpenTelemetry instrumentation outside Effect has already
+   * produced a parent span context and an effect should continue that trace.
+   *
+   * @category propagation
+   * @since 4.0.0
    */
   <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>(
@@ -356,14 +417,14 @@ export class OtelSpan implements Tracer.Span {
 
   readonly name: string
   readonly kind: Tracer.SpanKind
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<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
+  readonly parent: Option.Option<Tracer.AnySpan>
   status: Tracer.SpanStatus
 
   constructor(
@@ -378,9 +439,9 @@ export class OtelSpan implements Tracer.Span {
     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.parent = options.root !== true
+      ? Option.orElse(options.parent, () => getOtelParent(traceApi, active, options.annotations))
+      : options.parent
     this.span = tracer.startSpan(
       options.name,
       {
@@ -393,7 +454,9 @@ export class OtelSpan implements Tracer.Span {
           : undefined as any,
         kind: kindMap[this.kind]
       },
-      this.parent ? populateContext(active, this.parent, options.annotations) : Otel.trace.deleteSpan(active)
+      Option.isSome(this.parent) ?
+        populateContext(active, this.parent.value, options.annotations) :
+        Otel.trace.deleteSpan(active)
     )
     const spanContext = this.span.spanContext()
     this.spanId = spanContext.spanId
@@ -469,30 +532,24 @@ export class OtelSpan implements Tracer.Span {
 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
+  annotations: Context.Context<never>
+): Option.Option<Tracer.AnySpan> => {
+  const otelParent = tracer.getSpan(context)?.spanContext()
+  if (!otelParent) return Option.none()
+  return Option.some(Tracer.externalSpan({
+    spanId: otelParent.spanId,
+    traceId: otelParent.traceId,
+    sampled: (otelParent.traceFlags & 1) === 1,
+    annotations
+  }))
 }
 
 const makeSpanContext = (
   span: Tracer.AnySpan,
-  annotations?: ServiceMap.ServiceMap<never>
+  annotations?: Context.Context<never>
 ): Otel.SpanContext => {
   const traceFlags = makeTraceFlags(span, annotations)
   const traceState = makeTraceState(span, annotations)!
@@ -507,13 +564,13 @@ const makeSpanContext = (
 
 const makeTraceFlags = (
   span: Tracer.AnySpan,
-  annotations: ServiceMap.ServiceMap<never> | undefined
+  annotations: Context.Context<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)
+      traceFlags = Context.getOrUndefined(span.annotations, OtelTraceFlags)
     }
   }
   return traceFlags ?? Otel.TraceFlags.SAMPLED
@@ -521,13 +578,13 @@ const makeTraceFlags = (
 
 const makeTraceState = (
   span: Tracer.AnySpan,
-  annotations: ServiceMap.ServiceMap<never> | undefined
+  annotations: Context.Context<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)
+      traceState = Context.getOrUndefined(span.annotations, OtelTraceState)
     }
   }
   return traceState
@@ -535,20 +592,20 @@ const makeTraceState = (
 
 const extractTraceService = <I, S>(
   parent: Tracer.AnySpan,
-  annotations: ServiceMap.ServiceMap<never>,
-  service: ServiceMap.Service<I, S>
+  annotations: Context.Context<never>,
+  service: Context.Service<I, S>
 ) => {
-  const instance = ServiceMap.getOrUndefined(annotations, service)
+  const instance = Context.getOrUndefined(annotations, service)
   if (Predicate.isNotUndefined(instance)) {
     return instance
   }
-  return ServiceMap.getOrUndefined(parent.annotations, service)
+  return Context.getOrUndefined(parent.annotations, service)
 }
 
 const populateContext = (
   context: Otel.Context,
   span: Tracer.AnySpan,
-  annotations?: ServiceMap.ServiceMap<never> | undefined
+  annotations?: Context.Context<never> | undefined
 ): Otel.Context =>
   span instanceof OtelSpan ?
     Otel.trace.setSpan(context, span.span) :

package/src/WebSdk.ts

@@ -1,5 +1,31 @@
 /**
- * @since 1.0.0
+ * Provides an Effect layer for configuring OpenTelemetry in browser
+ * applications. The module builds a shared resource from explicit service
+ * metadata and wires Effect tracing, metrics, and logging into OpenTelemetry
+ * SDK providers when span processors, metric readers, or log record processors
+ * are supplied.
+ *
+ * Use this module in client-side applications that need Effect spans, metrics,
+ * and logs exported from browser runtimes, such as single-page apps,
+ * multi-page apps with hydrated Effect code, frontend workers, or UI flows
+ * that should be correlated with backend traces. Telemetry is enabled only for
+ * the configured signal types, so tracing, metrics, and logging can be
+ * installed independently from the same layer.
+ *
+ * Browser SDKs cannot rely on process environment resource configuration, so
+ * provide stable service metadata explicitly and use resource attributes for
+ * application, release, deployment, or page-shell identity rather than
+ * per-event data. This module does not create exporters; supply
+ * browser-compatible processors, readers, and exporters yourself, and make sure
+ * their endpoints are reachable from the browser with the required CORS and
+ * authentication behavior. The layer is scoped: tracer providers are
+ * force-flushed and shut down when the scope is released, while metric readers
+ * and logger providers follow their respective layer lifecycles. Keep the
+ * scope alive for the lifetime of the browser application and release it during
+ * application teardown when possible so batched exporters and periodic metric
+ * readers can deliver buffered telemetry before the page is unloaded.
+ *
+ * @since 4.0.0
  */
 import type * as Otel from "@opentelemetry/api"
 import type { LoggerProviderConfig, LogRecordProcessor } from "@opentelemetry/sdk-logs"
@@ -17,8 +43,10 @@ import * as Resource from "./Resource.ts"
 import * as Tracer from "./Tracer.ts"
 
 /**
- * @since 1.0.0
- * @category Models
+ * Configuration for the Web OpenTelemetry layer, including resource metadata and optional tracing, metrics, and logging settings.
+ *
+ * @category models
+ * @since 4.0.0
  */
 export interface Configuration {
   readonly spanProcessor?: SpanProcessor | ReadonlyArray<SpanProcessor> | undefined
@@ -36,8 +64,10 @@ export interface Configuration {
 }
 
 /**
- * @since 1.0.0
- * @category Layers
+ * Creates a scoped Web OpenTelemetry tracer provider from one or more span processors and shuts it down when the layer is released.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layerTracerProvider = (
   processor: SpanProcessor | NonEmptyReadonlyArray<SpanProcessor>,
@@ -65,18 +95,81 @@ export const layerTracerProvider = (
   )
 
 /**
- * @since 1.0.0
- * @category Layers
+ * Creates a Web OpenTelemetry layer from configuration, providing the resource and enabling tracing, metrics, and logging when configured.
+ *
+ * **When to use**
+ *
+ * Use to install browser OpenTelemetry support for an Effect application when
+ * service metadata is provided in code and tracing, metrics, or logging should
+ * be enabled from supplied span processors, metric readers, or log record
+ * processors.
+ *
+ * **Details**
+ *
+ * The configuration can be provided lazily or effectfully. The layer always
+ * provides `Resource.Resource`; tracing, metrics, and logging are installed only
+ * when the corresponding processors or readers are non-empty.
+ *
+ * **Gotchas**
+ *
+ * Browser resource metadata is explicit; this layer does not read
+ * OpenTelemetry environment variables. Empty processor or reader arrays are
+ * treated as not configured.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layer: {
   /**
-   * @since 1.0.0
-   * @category Layers
+   * Creates a Web OpenTelemetry layer from configuration, providing the resource and enabling tracing, metrics, and logging when configured.
+   *
+   * **When to use**
+   *
+   * Use to install browser OpenTelemetry support for an Effect application when
+   * service metadata is provided in code and tracing, metrics, or logging should
+   * be enabled from supplied span processors, metric readers, or log record
+   * processors.
+   *
+   * **Details**
+   *
+   * The configuration can be provided lazily or effectfully. The layer always
+   * provides `Resource.Resource`; tracing, metrics, and logging are installed only
+   * when the corresponding processors or readers are non-empty.
+   *
+   * **Gotchas**
+   *
+   * Browser resource metadata is explicit; this layer does not read
+   * OpenTelemetry environment variables. Empty processor or reader arrays are
+   * treated as not configured.
+   *
+   * @category layers
+   * @since 4.0.0
    */
   (evaluate: LazyArg<Configuration>): Layer.Layer<Resource.Resource>
   /**
-   * @since 1.0.0
-   * @category Layers
+   * Creates a Web OpenTelemetry layer from configuration, providing the resource and enabling tracing, metrics, and logging when configured.
+   *
+   * **When to use**
+   *
+   * Use to install browser OpenTelemetry support for an Effect application when
+   * service metadata is provided in code and tracing, metrics, or logging should
+   * be enabled from supplied span processors, metric readers, or log record
+   * processors.
+   *
+   * **Details**
+   *
+   * The configuration can be provided lazily or effectfully. The layer always
+   * provides `Resource.Resource`; tracing, metrics, and logging are installed only
+   * when the corresponding processors or readers are non-empty.
+   *
+   * **Gotchas**
+   *
+   * Browser resource metadata is explicit; this layer does not read
+   * OpenTelemetry environment variables. Empty processor or reader arrays are
+   * treated as not configured.
+   *
+   * @category layers
+   * @since 4.0.0
    */
   <E, R>(evaluate: Effect.Effect<Configuration, E, R>): Layer.Layer<Resource.Resource, E, R>
 } = (

package/src/index.ts

@@ -1,35 +1,35 @@
 /**
- * @since 1.0.0
+ * @since 4.0.0
  */
 
 // @barrel: Auto-generated exports. Do not edit manually.
 
 /**
- * @since 1.0.0
+ * @since 4.0.0
  */
 export * as Logger from "./Logger.ts"
 
 /**
- * @since 1.0.0
+ * @since 4.0.0
  */
 export * as Metrics from "./Metrics.ts"
 
 /**
- * @since 1.0.0
+ * @since 4.0.0
  */
 export * as NodeSdk from "./NodeSdk.ts"
 
 /**
- * @since 1.0.0
+ * @since 4.0.0
  */
 export * as Resource from "./Resource.ts"
 
 /**
- * @since 1.0.0
+ * @since 4.0.0
  */
 export * as Tracer from "./Tracer.ts"
 
 /**
- * @since 1.0.0
+ * @since 4.0.0
  */
 export * as WebSdk from "./WebSdk.ts"

package/src/internal/attributes.ts

@@ -1,6 +1,13 @@
 import type * as Otel from "@opentelemetry/api"
 import * as Inspectable from "effect/Inspectable"
 
+const bigint1e9 = BigInt(1_000_000_000)
+
+/** @internal */
+export const nanosToHrTime = (timestamp: bigint): Otel.HrTime => {
+  return [Number(timestamp / bigint1e9), Number(timestamp % bigint1e9)]
+}
+
 /** @internal */
 export const recordToAttributes = (record: Record<string, unknown>): Otel.Attributes => {
   const attributes: Otel.Attributes = {}