@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 06:00 UTC

main
ts 164 lines 5.56 KB
Raw
1 /**
2 * OpenTelemetry support for Effect metrics.
3 *
4 * This module exposes Effect metrics as an OpenTelemetry `MetricProducer`.
5 * `makeProducer` creates the producer, `registerProducer` attaches it to one
6 * or more SDK `MetricReader`s, and `layer` manages that setup in a scoped
7 * layer. The `TemporalityPreference` type lets callers choose cumulative or
8 * delta metric values.
9 *
10 * @stability unstable
11 * @since 4.0.0
12 */
13 import type { MetricProducer, MetricReader } from "@opentelemetry/sdk-metrics"
14 import type * as Arr from "effect/Array"
15 import type * as Duration from "effect/Duration"
16 import * as Effect from "effect/Effect"
17 import type { LazyArg } from "effect/Function"
18 import * as Layer from "effect/Layer"
19 import type * as Scope from "effect/Scope"
20 import { MetricProducerImpl } from "./internal/metrics.ts"
21 import { Resource } from "./Resource.ts"
22
23 /**
24 * Determines how metric values relate to the time interval over which they
25 * are aggregated.
26 *
27 * **Details**
28 *
29 * `cumulative` reports total since a fixed start time. Each data point depends
30 * on all previous measurements. This is the default behavior. `delta` reports
31 * changes since the last export. Each interval is independent with no
32 * dependency on previous measurements.
33 *
34 * @stability unstable
35 * @category models
36 * @since 4.0.0
37 */
38 export type TemporalityPreference = "cumulative" | "delta"
39
40 /**
41 * Creates an OpenTelemetry metric producer from Effect metrics.
42 *
43 * **When to use**
44 *
45 * Use when you need a `MetricProducer` for manually wiring Effect metrics into
46 * OpenTelemetry instead of using the scoped `layer` helper.
47 *
48 * **Details**
49 *
50 * Requires the current OpenTelemetry `Resource`, captures the current Effect
51 * context, and uses cumulative temporality by default. Pass `"delta"` for
52 * interval-based values.
53 *
54 * @see {@link registerProducer} for attaching a producer to metric readers
55 * @see {@link layer} for creating and registering a producer in a scoped layer
56 *
57 * @stability unstable
58 * @category constructors
59 * @since 4.0.0
60 */
61 export const makeProducer = (temporality?: TemporalityPreference): Effect.Effect<MetricProducer, never, Resource> =>
62 Effect.gen(function*() {
63 const resource = yield* Resource
64 const services = yield* Effect.context<never>()
65 return new MetricProducerImpl(resource, services, temporality)
66 })
67
68 /**
69 * Registers a metric producer with one or more metric readers.
70 *
71 * @stability unstable
72 * @category resource management
73 * @since 4.0.0
74 */
75 export const registerProducer = (
76 self: MetricProducer,
77 metricReader: LazyArg<MetricReader | Arr.NonEmptyReadonlyArray<MetricReader>>,
78 options?: {
79 readonly shutdownTimeout?: Duration.Input | undefined
80 }
81 ): Effect.Effect<Array<any>, never, Scope.Scope> =>
82 Effect.acquireRelease(
83 Effect.suspend(() => {
84 const reader = metricReader()
85 const readers: Array<MetricReader> = Array.isArray(reader) ? reader : [reader] as any
86 const bound: Array<MetricReader> = []
87 try {
88 for (const reader of readers) {
89 reader.setMetricProducer(self instanceof MetricProducerImpl ? self.fork() : self)
90 bound.push(reader)
91 }
92 return Effect.succeed(bound)
93 } catch (error) {
94 // Roll back only the readers bound by this acquisition.
95 return Effect.andThen(Effect.ignoreCause(shutdownReaders(bound, options)), Effect.die(error))
96 }
97 }),
98 (readers) => shutdownReaders(readers, options)
99 )
100
101 const shutdownReaders = (
102 readers: ReadonlyArray<MetricReader>,
103 options?: { readonly shutdownTimeout?: Duration.Input | undefined }
104 ) =>
105 Effect.promise(() => Promise.all(readers.map((reader) => reader.shutdown()))).pipe(
106 Effect.ignore,
107 Effect.interruptible,
108 Effect.timeoutOption(options?.shutdownTimeout ?? 3000)
109 )
110
111 /**
112 * Creates a Layer that registers a metric producer with metric readers.
113 *
114 * **Example** (Exporting delta metrics)
115 *
116 * ```ts import.meta.vitest
117 * import { OtelMetrics, Resource } from "@effect/opentelemetry"
118 * import {
119 * AggregationTemporality,
120 * InMemoryMetricExporter,
121 * PeriodicExportingMetricReader
122 * } from "@opentelemetry/sdk-metrics"
123 * import { Effect, Layer, Metric } from "effect"
124 *
125 * const exporter = new InMemoryMetricExporter(AggregationTemporality.DELTA)
126 * const reader = new PeriodicExportingMetricReader({
127 * exporter,
128 * exportIntervalMillis: 60_000
129 * })
130 * const metricsLayer = OtelMetrics.layer(() => reader, { temporality: "delta" }).pipe(
131 * Layer.provide(Resource.layerEmpty)
132 * )
133 *
134 * const program = Effect.gen(function*() {
135 * yield* Metric.update(Metric.counter("docs.requests", { incremental: true }), 2)
136 * yield* Effect.promise(() => reader.forceFlush())
137 *
138 * const metric = exporter.getMetrics()[0]?.scopeMetrics[0]?.metrics.find(
139 * (metric) => metric.descriptor.name === "docs.requests"
140 * )
141 * return [metric?.descriptor.name, metric?.aggregationTemporality, metric?.dataPoints[0]?.value] as const
142 * }).pipe(
143 * Effect.provide(metricsLayer),
144 * Effect.provideService(Metric.MetricRegistry, new Map())
145 * )
146 *
147 * await Effect.runPromise(program) // => ["docs.requests", AggregationTemporality.DELTA, 2]
148 * ```
149 *
150 * @stability unstable
151 * @category layers
152 * @since 4.0.0
153 */
154 export const layer = (
155 evaluate: LazyArg<MetricReader | Arr.NonEmptyReadonlyArray<MetricReader>>,
156 options?: {
157 readonly shutdownTimeout?: Duration.Input | undefined
158 readonly temporality?: TemporalityPreference | undefined
159 }
160 ): Layer.Layer<never, never, Resource> =>
161 Layer.effectDiscard(Effect.flatMap(
162 makeProducer(options?.temporality),
163 (producer) => registerProducer(producer, evaluate, options)
164 ))