@effect/opentelemetry 0.9.0 → 0.10.0

package/src/internal/metrics.ts

@@ -0,0 +1,261 @@
+import type { LazyArg } from "@effect/data/Function"
+import * as HashSet from "@effect/data/HashSet"
+import * as Option from "@effect/data/Option"
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
+import * as Metric from "@effect/io/Metric"
+import type * as MetricKey from "@effect/io/MetricKey"
+import * as MetricKeyType from "@effect/io/MetricKeyType"
+import * as MetricState from "@effect/io/MetricState"
+import * as Resource from "@effect/opentelemetry/Resource"
+import type { HrTime } from "@opentelemetry/api"
+import { ValueType } from "@opentelemetry/api"
+import type * as Resources from "@opentelemetry/resources"
+import type {
+  CollectionResult,
+  DataPoint,
+  InstrumentDescriptor,
+  MetricData,
+  MetricReader
+} from "@opentelemetry/sdk-metrics"
+import { AggregationTemporality, DataPointType, InstrumentType } from "@opentelemetry/sdk-metrics"
+import type { MetricCollectOptions, MetricProducer } from "@opentelemetry/sdk-metrics/build/src/export/MetricProducer"
+
+const sdkName = "@effect/opentelemetry/Metrics"
+
+/** @internal */
+export class MetricProducerImpl implements MetricProducer {
+  constructor(readonly resource: Resources.Resource) {
+  }
+
+  collect(_options?: MetricCollectOptions): Promise<CollectionResult> {
+    const snapshot = Metric.unsafeSnapshot()
+    const hrTimeNow = currentHrTime()
+    const metricData: Array<MetricData> = []
+
+    for (const { metricKey, metricState } of snapshot) {
+      const attributes = HashSet.reduce(metricKey.tags, {}, (acc: Record<string, string>, label) => {
+        acc[label.key] = label.value
+        return acc
+      })
+      const descriptor = descriptorFromKey(metricKey, attributes)
+
+      if (MetricState.isCounterState(metricState)) {
+        metricData.push({
+          dataPointType: DataPointType.SUM,
+          descriptor,
+          isMonotonic: descriptor.type === InstrumentType.COUNTER,
+          aggregationTemporality: AggregationTemporality.CUMULATIVE,
+          dataPoints: [{
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes,
+            value: metricState.count
+          }]
+        })
+      } else if (MetricState.isGaugeState(metricState)) {
+        metricData.push({
+          dataPointType: DataPointType.GAUGE,
+          descriptor,
+          aggregationTemporality: AggregationTemporality.CUMULATIVE,
+          dataPoints: [{
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes,
+            value: metricState.value
+          }]
+        })
+      } else if (MetricState.isHistogramState(metricState)) {
+        const size = metricState.buckets.length
+        const buckets = {
+          boundaries: Array<number>(size - 1),
+          counts: Array<number>(size)
+        }
+        let i = 0
+        let prev = 0
+        for (const [boundary, value] of metricState.buckets) {
+          if (i < size - 1) {
+            buckets.boundaries[i] = boundary
+          }
+          buckets.counts[i] = value - prev
+          prev = value
+          i++
+        }
+
+        metricData.push({
+          dataPointType: DataPointType.HISTOGRAM,
+          descriptor,
+          aggregationTemporality: AggregationTemporality.CUMULATIVE,
+          dataPoints: [{
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes,
+            value: {
+              buckets,
+              count: metricState.count,
+              min: metricState.min,
+              max: metricState.max,
+              sum: metricState.sum
+            }
+          }]
+        })
+      } else if (MetricState.isFrequencyState(metricState)) {
+        const dataPoints: Array<DataPoint<number>> = []
+        for (const [freqKey, value] of metricState.occurrences) {
+          dataPoints.push({
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes: {
+              ...attributes,
+              key: freqKey
+            },
+            value
+          })
+        }
+        metricData.push({
+          dataPointType: DataPointType.SUM,
+          descriptor: descriptorFromKey(metricKey, attributes),
+          aggregationTemporality: AggregationTemporality.CUMULATIVE,
+          isMonotonic: true,
+          dataPoints
+        })
+      } else if (MetricState.isSummaryState(metricState)) {
+        const dataPoints: Array<DataPoint<number>> = [{
+          startTime: hrTimeNow,
+          endTime: hrTimeNow,
+          attributes: { ...attributes, quantile: "min" },
+          value: metricState.min
+        }]
+        for (const [quantile, value] of metricState.quantiles) {
+          dataPoints.push({
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes: { ...attributes, quantile: quantile.toString() },
+            value: value._tag === "Some" ? value.value : 0
+          })
+        }
+        dataPoints.push({
+          startTime: hrTimeNow,
+          endTime: hrTimeNow,
+          attributes: { ...attributes, quantile: "max" },
+          value: metricState.max
+        })
+
+        metricData.push({
+          dataPointType: DataPointType.SUM,
+          descriptor: descriptorFromKey(metricKey, attributes, "quantiles"),
+          aggregationTemporality: AggregationTemporality.CUMULATIVE,
+          isMonotonic: false,
+          dataPoints
+        })
+        metricData.push({
+          dataPointType: DataPointType.SUM,
+          descriptor: {
+            ...descriptorMeta(metricKey, "count"),
+            unit: "1",
+            type: InstrumentType.COUNTER,
+            valueType: ValueType.INT
+          },
+          aggregationTemporality: AggregationTemporality.CUMULATIVE,
+          isMonotonic: true,
+          dataPoints: [{
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes,
+            value: metricState.count
+          }]
+        })
+        metricData.push({
+          dataPointType: DataPointType.SUM,
+          descriptor: {
+            ...descriptorMeta(metricKey, "sum"),
+            unit: "1",
+            type: InstrumentType.COUNTER,
+            valueType: ValueType.DOUBLE
+          },
+          aggregationTemporality: AggregationTemporality.CUMULATIVE,
+          isMonotonic: true,
+          dataPoints: [{
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes,
+            value: metricState.sum
+          }]
+        })
+      }
+    }
+
+    return Promise.resolve({
+      resourceMetrics: {
+        resource: this.resource,
+        scopeMetrics: [{
+          scope: { name: sdkName },
+          metrics: metricData
+        }]
+      },
+      errors: []
+    })
+  }
+}
+
+const descriptorMeta = (
+  metricKey: MetricKey.MetricKey.Untyped,
+  suffix?: string
+) => ({
+  name: suffix ? `${metricKey.name}_${suffix}` : metricKey.name,
+  description: Option.getOrElse(metricKey.description, () => "")
+})
+
+const descriptorFromKey = (
+  metricKey: MetricKey.MetricKey.Untyped,
+  tags: Record<string, string>,
+  suffix?: string
+): InstrumentDescriptor => ({
+  ...descriptorMeta(metricKey, suffix),
+  unit: tags.unit ?? tags.time_unit ?? "1",
+  type: instrumentTypeFromKey(metricKey),
+  valueType: ValueType.DOUBLE
+})
+
+const instrumentTypeFromKey = (key: MetricKey.MetricKey.Untyped): InstrumentType => {
+  if (MetricKeyType.isHistogramKey(key.keyType)) {
+    return InstrumentType.HISTOGRAM
+  } else if (MetricKeyType.isGaugeKey(key.keyType)) {
+    return InstrumentType.OBSERVABLE_GAUGE
+  } else if (MetricKeyType.isSummaryKey(key.keyType)) {
+    return InstrumentType.UP_DOWN_COUNTER
+  } else if (MetricKeyType.isFrequencyKey(key.keyType)) {
+    return InstrumentType.COUNTER
+  }
+
+  return InstrumentType.UP_DOWN_COUNTER
+}
+
+const currentHrTime = (): HrTime => {
+  const now = Date.now()
+  return [Math.floor(now / 1000), (now % 1000) * 1000000]
+}
+
+/** @internal */
+export const makeProducer = Effect.map(
+  Resource.Resource,
+  (resource): MetricProducer => new MetricProducerImpl(resource)
+)
+
+/** @internal */
+export const registerProducer = (self: MetricProducer, metricReader: LazyArg<MetricReader>) =>
+  Effect.acquireRelease(
+    Effect.sync(() => {
+      const reader = metricReader()
+      reader.setMetricProducer(self)
+      return reader
+    }),
+    (reader) => Effect.promise(() => reader.shutdown())
+  )
+
+/** @internal */
+export const layer = (evaluate: LazyArg<MetricReader>) =>
+  Layer.scopedDiscard(Effect.flatMap(
+    makeProducer,
+    (producer) => registerProducer(producer, evaluate)
+  ))

package/src/internal/tracer.ts

@@ -5,11 +5,9 @@ import * as Option from "@effect/data/Option"
 import * as Cause from "@effect/io/Cause"
 import * as Effect from "@effect/io/Effect"
 import type { Exit } from "@effect/io/Exit"
-import type { RuntimeFiber } from "@effect/io/Fiber"
 import * as FiberRef from "@effect/io/FiberRef"
 import * as FiberRefs from "@effect/io/FiberRefs"
 import * as Layer from "@effect/io/Layer"
-import * as Supervisor from "@effect/io/Supervisor"
 import * as Tracer from "@effect/io/Tracer"
 import { Resource } from "@effect/opentelemetry/Resource"
 import * as OtelApi from "@opentelemetry/api"
@@ -34,23 +32,18 @@ export class OtelSpan implements Tracer.Span {
     startTime: bigint
   ) {
     const active = contextApi.active()
-    this.span = tracer.startSpan(
-      name,
-      {
-        startTime: nanosToHrTime(startTime),
-        links: links.length > 0 ?
-          links.map((link) => ({
-            context: makeSpanContext(link.span),
-            attributes: link.attributes
-          })) :
-          undefined
-      },
-      parent._tag === "Some" ? populateContext(active, parent.value, context) : active
-    )
+    this.span = tracer.startSpan(name, {
+      startTime: nanosToHrTime(startTime),
+      links: links.length > 0
+        ? links.map((link) => ({
+          context: makeSpanContext(link.span),
+          attributes: link.attributes
+        }))
+        : undefined
+    }, parent._tag === "Some" ? populateContext(active, parent.value, context) : active)
     const spanContext = this.span.spanContext()
     this.spanId = spanContext.spanId
     this.traceId = spanContext.traceId
-
     this.status = {
       _tag: "Started",
       startTime
@@ -120,6 +113,24 @@ export const make = pipe(
           links,
           startTime
         )
+      },
+      context(execution, fiber) {
+        const currentSpan = Option.flatMap(
+          FiberRefs.get(
+            fiber.unsafeGetFiberRefs(),
+            FiberRef.currentTracerSpan
+          ),
+          List.head
+        )
+
+        if (currentSpan._tag === "None") {
+          return execution()
+        }
+
+        return OtelApi.context.with(
+          populateContext(OtelApi.context.active(), currentSpan.value),
+          execution
+        )
       }
     })
   )
@@ -160,39 +171,7 @@ export const makeExternalSpan = (options: {
 }
 
 /** @internal */
-export class OtelSupervisor extends Supervisor.AbstractSupervisor<void> {
-  value(): Effect.Effect<never, never, void> {
-    return Effect.unit
-  }
-
-  onRun<E, A, X>(execution: () => X, fiber: RuntimeFiber<E, A>): X {
-    const currentSpan = Option.flatMap(
-      FiberRefs.get(
-        fiber.unsafeGetFiberRefs(),
-        FiberRef.currentTracerSpan
-      ),
-      List.head
-    )
-
-    if (currentSpan._tag === "None") {
-      return execution()
-    }
-
-    return OtelApi.context.with(
-      populateContext(OtelApi.context.active(), currentSpan.value),
-      execution
-    )
-  }
-}
-
-/** @internal */
-export const supervisor = new OtelSupervisor()
-
-/** @internal */
-export const layer = Layer.merge(
-  Layer.unwrapEffect(Effect.map(make, Effect.setTracer)),
-  Supervisor.addSupervisor(supervisor)
-)
+export const layer = Layer.unwrapEffect(Effect.map(make, Effect.setTracer))
 
 // -------------------------------------------------------------------------------------
 // utils