@livestore/utils 0.0.0

package/src/effect/Otel/Meter.ts

@@ -0,0 +1,145 @@
+import * as Context from '@effect/data/Context'
+import { identity, pipe } from '@effect/data/Function'
+import * as Effect from '@effect/io/Effect'
+import * as Layer from '@effect/io/Layer'
+import type * as OTMetrics from '@opentelemetry/api-metrics'
+
+import { MetricsProvider } from './lib-metrics/MetricsProvider.js'
+
+export const MeterSymbol = Symbol.for('effect-otel/Meter')
+export type MeterSymbol = typeof MeterSymbol
+
+export interface Meter {
+  readonly [MeterSymbol]: MeterSymbol
+  readonly meter: OTMetrics.Meter
+}
+
+export const Meter = Context.Tag<Meter>(MeterSymbol)
+
+export const makeMeter = (name: string) =>
+  Effect.gen(function* ($) {
+    const { metricsProvider } = yield* $(MetricsProvider)
+
+    const meter = yield* $(Effect.sync(() => metricsProvider.getMeter(name)))
+
+    return identity<Meter>({
+      [MeterSymbol]: MeterSymbol,
+      meter,
+    })
+  })
+
+export const LiveMeter = Layer.scoped(Meter, makeMeter('@effect/otel/Meter'))
+
+type MetricCache = {
+  histograms: Map<string, OTMetrics.Histogram>
+  gauges: Map<string, { counter: OTMetrics.Counter; prevValue: number }>
+  // gauges: Map<string, { observable: OTMetrics.ObservableGauge; currentCallback: OTMetrics.ObservableCallback }>
+  upDownCounters: Map<string, OTMetrics.Counter>
+}
+
+const metricCache: MetricCache = {
+  histograms: new Map(),
+  gauges: new Map(),
+  upDownCounters: new Map(),
+}
+
+export const histogram =
+  (metricName: string, value: number, attributes?: OTMetrics.MetricAttributes) =>
+  <R, E, A>(effect: Effect.Effect<R, E, A>) =>
+    Effect.tap(effect, () =>
+      pipe(
+        Effect.map(Meter, ({ meter }) =>
+          getOrCreate(metricCache.histograms, metricName, () => meter.createHistogram(metricName)),
+        ),
+        Effect.tap((histogram) => Effect.sync(() => histogram.record(value, attributes))),
+      ),
+    )
+
+export const histogramEff =
+  <R2>(metricName: string, valueEff: Effect.Effect<R2, never, number>) =>
+  <R, E, A>(effect: Effect.Effect<R, E, A>) =>
+    Effect.tap(effect, () =>
+      pipe(
+        Effect.map(Meter, ({ meter }) =>
+          getOrCreate(metricCache.histograms, metricName, () => meter.createHistogram(metricName)),
+        ),
+        Effect.tap((histogram) => Effect.map(valueEff, (value) => histogram.record(value))),
+      ),
+    )
+
+export const upDownCounter =
+  (metricName: string, delta: number, attributes?: OTMetrics.MetricAttributes) =>
+  <R, E, A>(effect: Effect.Effect<R, E, A>) =>
+    Effect.tap(effect, () =>
+      pipe(
+        Effect.map(Meter, ({ meter }) =>
+          getOrCreate(metricCache.upDownCounters, metricName, () => meter.createUpDownCounter(metricName)),
+        ),
+        Effect.tap((counter) => Effect.sync(() => counter.add(delta, attributes))),
+      ),
+    )
+
+/** NOTE we're using an up-down-counter here (which is push based) instead of an observable gauge (which is pull based) */
+export const gauge =
+  (metricName: string, value: number, attributes?: OTMetrics.MetricAttributes) =>
+  <R, E, A>(effect: Effect.Effect<R, E, A>) => {
+    // NOTE this is currently used to keep separate gauges for each attribute value
+    const metricCacheName = metricName + '_' + JSON.stringify(attributes)
+    return Effect.tap(effect, () =>
+      pipe(
+        Effect.map(Meter, ({ meter }) =>
+          getOrCreate(metricCache.gauges, metricCacheName, () => ({
+            counter: meter.createUpDownCounter(metricName),
+            prevValue: 0,
+          })),
+        ),
+        Effect.tap(({ counter, prevValue }) =>
+          Effect.sync(() => {
+            const delta = value - prevValue
+            counter.add(delta, attributes)
+            metricCache.gauges.set(metricCacheName, { counter, prevValue: value })
+          }),
+        ),
+      ),
+    )
+  }
+
+// export const gauge =
+//   (metricName: string, value: number, attributes?: OTMetrics.MetricAttributes) =>
+//   <R, E, A>(effect: Effect.Effect<R, E, A>) => {
+//     // NOTE this is currently used to keep separate gauges for each attribute value
+//     const metricCacheName = metricName + '_' + JSON.stringify(attributes)
+//     return pipe(
+//       effect,
+//       Effect.tap(() =>
+//         pipe(
+//           withMeter((meter) =>
+//             getOrCreate(metricCache.gauges, metricCacheName, () => ({
+//               observable: meter.createObservableGauge(metricName),
+//               currentCallback: () => {},
+//             })),
+//           ),
+//           Effect.tap(({ observable, currentCallback }) =>
+//             Effect.succeedWith(() => {
+//               observable.removeCallback(currentCallback)
+//               const newCallback: OTMetrics.ObservableCallback = (observableResult) => {
+//                 observableResult.observe(value, attributes)
+//               }
+//               observable.addCallback(newCallback)
+//               metricCache.gauges.set(metricCacheName, { observable, currentCallback: newCallback })
+//             }),
+//           ),
+//         ),
+//       ),
+//     )
+//   }
+
+const getOrCreate = <T>(map: Map<string, T>, name: string, create: () => T) => {
+  const cached = map.get(name)
+  if (cached) {
+    return cached
+  }
+  const created = create()
+  map.set(name, created)
+  return created
+}

package/src/effect/Otel/OtlpGrpc.ts

@@ -0,0 +1,75 @@
+import * as Layer from '@effect/io/Layer'
+import type { ResourceAttributes } from '@opentelemetry/resources'
+import { Resource } from '@opentelemetry/resources'
+import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions'
+
+import * as Otel from './index.js'
+import { makeOTLPMetricExporterConfigLayer } from './lib-metrics/ExporterMetricsOltpGrpc.js'
+import { OTLPMetricsProvider } from './lib-metrics/OTLPMetricsProviderGrpc.js'
+import { BatchProcessor } from './lib-tracer/BatchSpanProcessor.js'
+import * as GrpcExporter from './lib-tracer/ExporterTraceOtlpGrpc.js'
+import * as OTWeb from './lib-tracer/WebProvider.js'
+import { LiveMeter } from './Meter.js'
+
+//
+// TRACING
+//
+
+const makeWebTracingProvider = (serviceName: string, resourceAttributes?: ResourceAttributes) =>
+  OTWeb.WebProvider({
+    resource: new Resource({
+      [SemanticResourceAttributes.SERVICE_NAME]: serviceName,
+      ...resourceAttributes,
+    }),
+  })
+
+const TraceCollectorConfig = (exporterUrl?: string) =>
+  GrpcExporter.makeOTLPTraceExporterConfigLayer({
+    // empty headers makes sure to use XHR instead of `navigator.sendBeacon`
+    headers: {},
+    url: exporterUrl,
+  })
+
+const LiveBatchGrpcProcessor = BatchProcessor(GrpcExporter.makeTracingSpanExporter)
+
+export const makeWebTracingLayer = (
+  serviceName: string,
+  exporterUrl?: string,
+  resourceAttributes?: ResourceAttributes,
+): Layer.Layer<never, never, Otel.Tracer> =>
+  Layer.provideMerge(
+    TraceCollectorConfig(exporterUrl),
+    Layer.provide(
+      Layer.provideMerge(makeWebTracingProvider(serviceName, resourceAttributes), LiveBatchGrpcProcessor),
+      Otel.LiveTracer,
+    ),
+  )
+
+//
+// METRICS
+//
+
+const makeWebMetricProvider = (serviceName: string, resourceAttributes?: ResourceAttributes) =>
+  OTLPMetricsProvider({
+    resource: new Resource({
+      [SemanticResourceAttributes.SERVICE_NAME]: serviceName,
+      ...resourceAttributes,
+    }),
+  })
+
+const MetricCollectorConfig = (exporterUrl?: string) =>
+  makeOTLPMetricExporterConfigLayer({
+    // empty headers makes sure to use XHR instead of `navigator.sendBeacon`
+    headers: {},
+    url: exporterUrl,
+  })
+
+export const makeWebMetricLayer = (
+  serviceName: string,
+  exporterUrl?: string,
+  resourceAttributes?: ResourceAttributes,
+): Layer.Layer<never, never, Otel.Meter> =>
+  Layer.provide(
+    Layer.provideMerge(MetricCollectorConfig(exporterUrl), makeWebMetricProvider(serviceName, resourceAttributes)),
+    LiveMeter,
+  )

package/src/effect/Otel/OtlpHttp.ts

@@ -0,0 +1,75 @@
+import * as Layer from '@effect/io/Layer'
+import type { ResourceAttributes } from '@opentelemetry/resources'
+import { Resource } from '@opentelemetry/resources'
+import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions'
+
+import * as Otel from './index.js'
+import { makeOTLPMetricExporterConfigLayer } from './lib-metrics/ExporterMetricsOltpHttp.js'
+import { OTLPMetricsProvider } from './lib-metrics/OTLPMetricsProviderHttp.js'
+import { BatchProcessor } from './lib-tracer/BatchSpanProcessor.js'
+import * as HttpExporter from './lib-tracer/ExporterTraceOtlpHttp.js'
+import * as OTWeb from './lib-tracer/WebProvider.js'
+import { LiveMeter } from './Meter.js'
+
+//
+// TRACING
+//
+
+const makeWebTracingProvider = (serviceName: string, resourceAttributes?: ResourceAttributes) =>
+  OTWeb.WebProvider({
+    resource: new Resource({
+      [SemanticResourceAttributes.SERVICE_NAME]: serviceName,
+      ...resourceAttributes,
+    }),
+  })
+
+const TraceCollectorConfig = (exporterUrl?: string) =>
+  HttpExporter.makeOTLPTraceExporterConfigLayer({
+    // empty headers makes sure to use XHR instead of `navigator.sendBeacon`
+    headers: {},
+    url: exporterUrl,
+  })
+
+const LiveBatchHttpProcessor = BatchProcessor(HttpExporter.makeTracingSpanExporter)
+
+export const makeWebTracingLayer = (
+  serviceName: string,
+  exporterUrl?: string,
+  resourceAttributes?: ResourceAttributes,
+): Layer.Layer<never, never, Otel.Tracer> =>
+  Layer.provideMerge(
+    TraceCollectorConfig(exporterUrl),
+    Layer.provide(
+      Layer.provideMerge(makeWebTracingProvider(serviceName, resourceAttributes), LiveBatchHttpProcessor),
+      Otel.LiveTracer,
+    ),
+  )
+
+//
+// METRICS
+//
+
+const makeWebMetricProvider = (serviceName: string, resourceAttributes?: ResourceAttributes) =>
+  OTLPMetricsProvider({
+    resource: new Resource({
+      [SemanticResourceAttributes.SERVICE_NAME]: serviceName,
+      ...resourceAttributes,
+    }),
+  })
+
+const MetricCollectorConfig = (exporterUrl?: string) =>
+  makeOTLPMetricExporterConfigLayer({
+    // empty headers makes sure to use XHR instead of `navigator.sendBeacon`
+    headers: {},
+    url: exporterUrl,
+  })
+
+export const makeWebMetricLayer = (
+  serviceName: string,
+  exporterUrl?: string,
+  resourceAttributes?: ResourceAttributes,
+): Layer.Layer<never, never, Otel.Meter> =>
+  Layer.provide(
+    Layer.provideMerge(MetricCollectorConfig(exporterUrl), makeWebMetricProvider(serviceName, resourceAttributes)),
+    LiveMeter,
+  )

package/src/effect/Otel/OtlpWebsocket.ts

@@ -0,0 +1,75 @@
+import * as Layer from '@effect/io/Layer'
+import type { ResourceAttributes } from '@opentelemetry/resources'
+import { Resource } from '@opentelemetry/resources'
+import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions'
+
+import * as Otel from './index.js'
+import { makeOTLPMetricExporterConfigLayer } from './lib-metrics/ExporterMetricsOltpWebsocket.js'
+import { OTLPMetricsProvider } from './lib-metrics/OTLPMetricsProviderWebsocket.js'
+import { BatchProcessor } from './lib-tracer/BatchSpanProcessor.js'
+import * as WebSocketExporter from './lib-tracer/ExporterTraceOtlpWebsocket.js'
+import * as OTWeb from './lib-tracer/WebProvider.js'
+import { LiveMeter } from './Meter.js'
+
+//
+// TRACING
+//
+
+const makeWebTracingProvider = (serviceName: string, resourceAttributes?: ResourceAttributes) =>
+  OTWeb.WebProvider({
+    resource: new Resource({
+      [SemanticResourceAttributes.SERVICE_NAME]: serviceName,
+      ...resourceAttributes,
+    }),
+  })
+
+const TraceCollectorConfig = (exporterUrl?: string) =>
+  WebSocketExporter.makeOTLPTraceExporterConfigLayer({
+    // empty headers makes sure to use XHR instead of `navigator.sendBeacon`
+    headers: {},
+    url: exporterUrl,
+  })
+
+const LiveBatchWebsocketProcessor = BatchProcessor(WebSocketExporter.makeTracingSpanExporter)
+
+export const makeWebTracingLayer = (
+  serviceName: string,
+  exporterUrl?: string,
+  resourceAttributes?: ResourceAttributes,
+): Layer.Layer<never, never, Otel.Tracer> =>
+  Layer.provideMerge(
+    TraceCollectorConfig(exporterUrl),
+    Layer.provide(
+      Layer.provideMerge(makeWebTracingProvider(serviceName, resourceAttributes), LiveBatchWebsocketProcessor),
+      Otel.LiveTracer,
+    ),
+  )
+
+//
+// METRICS
+//
+
+const makeWebMetricProvider = (serviceName: string, resourceAttributes?: ResourceAttributes) =>
+  OTLPMetricsProvider({
+    resource: new Resource({
+      [SemanticResourceAttributes.SERVICE_NAME]: serviceName,
+      ...resourceAttributes,
+    }),
+  })
+
+const MetricCollectorConfig = (exporterUrl?: string) =>
+  makeOTLPMetricExporterConfigLayer({
+    // empty headers makes sure to use XHR instead of `navigator.sendBeacon`
+    headers: {},
+    url: exporterUrl,
+  })
+
+export const makeWebMetricLayer = (
+  serviceName: string,
+  exporterUrl?: string,
+  resourceAttributes?: ResourceAttributes,
+): Layer.Layer<never, never, Otel.Meter> =>
+  Layer.provide(
+    Layer.provideMerge(MetricCollectorConfig(exporterUrl), makeWebMetricProvider(serviceName, resourceAttributes)),
+    LiveMeter,
+  )

package/src/effect/Otel/Span.ts

@@ -0,0 +1,222 @@
+import * as Context from '@effect/data/Context'
+import { pipe } from '@effect/data/Function'
+import * as Option from '@effect/data/Option'
+import * as Cause from '@effect/io/Cause'
+import * as Effect from '@effect/io/Effect'
+import * as Exit from '@effect/io/Exit'
+import * as Layer from '@effect/io/Layer'
+import * as Stream from '@effect/stream/Stream'
+import * as otel from '@opentelemetry/api'
+
+import { Tracer } from './Tracer.js'
+
+export const SpanSymbol = Symbol.for('effect-otel/Span')
+export type SpanSymbol = typeof SpanSymbol
+
+// TODO refactor to use 2nd `Context.Tag` type generic instead of symbol
+export interface Span {
+  readonly [SpanSymbol]: SpanSymbol
+  readonly span: otel.Span
+}
+
+export const Span = Context.Tag<Span>(SpanSymbol)
+
+export const makeSpan = (span: otel.Span): Span => ({
+  [SpanSymbol]: SpanSymbol,
+  span,
+})
+
+export const requireParentSpan = <R, E, A>(effect: Effect.Effect<R, E, A>): Effect.Effect<R | Span, E, A> => effect
+
+export const activeSpanContext: Effect.Effect<Span, never, otel.SpanContext> = Effect.map(Span, (_) =>
+  _.span.spanContext(),
+)
+
+export const activeContext: Effect.Effect<Span, never, otel.Context> = Effect.flatMap(Span, (_) =>
+  Effect.sync(() => otel.trace.setSpan(otel.context.active(), _.span)),
+)
+
+// TODO get rid of this
+const inProgressSpans = new Set<otel.Span>()
+// @ts-expect-error `inProgressSpans` is not a global variable
+globalThis.inProgressSpans = inProgressSpans
+
+// TODO get rid of this
+export const endInProgressSpans = Effect.sync(() => {
+  inProgressSpans.forEach((span) => span.end())
+  inProgressSpans.clear()
+})
+
+const startSpan = (
+  tracer: otel.Tracer,
+  context: Context.Context<never>,
+  name: string,
+  options: otel.SpanOptions | undefined,
+  ctx: otel.Context | undefined,
+): otel.Span => {
+  let span: otel.Span
+  const maybeSpan = Context.getOption(context, Span)
+  if (ctx !== undefined) {
+    span = tracer.startSpan(name, options, ctx)
+  } else if (options?.root !== true && Option.isSome(maybeSpan)) {
+    const ctx = otel.trace.setSpan(otel.context.active(), maybeSpan.value.span)
+    span = tracer.startSpan(name, options, ctx)
+  } else {
+    span = tracer.startSpan(name, { ...options, root: true })
+  }
+  inProgressSpans.add(span)
+  return span
+}
+
+const handleExit = <E, A>(span: otel.Span, exit: Exit.Exit<E, A>) =>
+  Effect.sync(() => {
+    if (Exit.isFailure(exit)) {
+      if (Cause.isInterruptedOnly(exit.cause)) {
+        // TODO in the future set a special status code for interruption (once Otel supports it)
+        span.setStatus({ code: otel.SpanStatusCode.OK, message: Cause.pretty(exit.cause) })
+        // NOTE as a workaround we're using the `span.label` attribute which is visible in Grafana
+        // See https://github.com/grafana/grafana/pull/50931
+        span.setAttribute('span.label', '⚠️ Interrupted️')
+      } else {
+        span.setStatus({ code: otel.SpanStatusCode.ERROR, message: Cause.pretty(exit.cause) })
+      }
+    } else {
+      span.setStatus({ code: otel.SpanStatusCode.OK })
+    }
+    inProgressSpans.delete(span)
+    span.end()
+  })
+
+export const withSpan =
+  (name: string, options?: otel.SpanOptions, ctx?: otel.Context) =>
+  <R, E, A>(effect: Effect.Effect<R, E, A>): Effect.Effect<Exclude<R, Span> | Tracer, E, A> =>
+    Effect.flatMap(Tracer, (tracer) =>
+      Effect.acquireUseRelease(
+        Effect.flatMap(Effect.context<never>(), (context) =>
+          Effect.sync(() => startSpan(tracer.tracer, context, name, options, ctx)),
+        ),
+        (span) => Effect.provideService(effect, Span, makeSpan(span)),
+        handleExit,
+      ),
+    )
+
+export const withSpanScoped =
+  (name: string, options?: otel.SpanOptions, ctx?: otel.Context) =>
+  <R, E, A>(effect: Effect.Effect<R, E, A>) =>
+    Effect.flatMap(Tracer, (tracer) => {
+      const createSpan = Effect.acquireRelease(
+        Effect.flatMap(Effect.context<never>(), (context) =>
+          Effect.sync(() => startSpan(tracer.tracer, context, name, options, ctx)),
+        ),
+        handleExit,
+      )
+
+      return Effect.flatMap(createSpan, (span) => Effect.provideService(effect, Span, makeSpan(span)))
+    })
+
+export const withSpanStream =
+  (name: string, options?: otel.SpanOptions, ctx?: otel.Context) =>
+  <R, E, A>(stream: Stream.Stream<R | Span, E, A>): Stream.Stream<Exclude<R, Span> | Tracer, E, A> =>
+    Stream.unwrapScoped(
+      Effect.flatMap(Tracer, (tracer) =>
+        pipe(
+          Effect.acquireRelease(
+            Effect.flatMap(Effect.context<never>(), (context) =>
+              Effect.sync(() => startSpan(tracer.tracer, context, name, options, ctx)),
+            ),
+            handleExit,
+          ),
+          Effect.map((span) => Stream.provideService(stream, Span, makeSpan(span))),
+        ),
+      ),
+    )
+
+// TODO add optional arg for `Tag` of `Span`
+export const spanLayer: {
+  (
+    name: string,
+    options?: otel.SpanOptions,
+    ctx?: otel.Context,
+    afterEnded?: (span: otel.Span) => Effect.Effect<never, never, void>,
+  ): Layer.Layer<Tracer, never, Span>
+  <TIdentifier>(
+    name: string,
+    options: otel.SpanOptions | undefined,
+    ctx: otel.Context | undefined,
+    afterEnded: ((span: otel.Span) => Effect.Effect<never, never, void>) | undefined,
+    tag: Context.Tag<TIdentifier, Span>,
+  ): Layer.Layer<Tracer, never, TIdentifier>
+} = <TIdentifier>(
+  name: string,
+  options?: otel.SpanOptions,
+  ctx?: otel.Context,
+  afterEnded?: (span: otel.Span) => Effect.Effect<never, never, void>,
+  tag?: Context.Tag<TIdentifier, Span>,
+): Layer.Layer<Tracer, never, TIdentifier> =>
+  Layer.flatMap(Layer.context<Tracer>(), (context) =>
+    Layer.scoped(
+      tag ?? Span,
+      pipe(
+        Effect.sync(() => {
+          const tracer = Context.get(context, Tracer)
+          return startSpan(tracer.tracer, context, name, options, ctx)
+        }),
+        Effect.map(makeSpan),
+        Effect.acquireRelease(({ span }, exit) =>
+          pipe(
+            handleExit(span, exit),
+            Effect.tap(() => {
+              if (afterEnded !== undefined) {
+                return afterEnded(span)
+              }
+              return Effect.unit
+            }),
+          ),
+        ),
+      ),
+    ),
+  )
+
+export const spanLayerFromContext = (parentSpanCtx: otel.Context) => {
+  // const _spanId = otel.trace.getSpan(parentSpanCtx)!.spanContext().spanId
+  return Layer.succeed(Span, makeSpan(otel.trace.getSpan(parentSpanCtx)!))
+}
+
+export const withSpanLayer =
+  (name: string, options?: otel.SpanOptions, ctx?: otel.Context) =>
+  <R, E, A>(layer: Layer.Layer<R | Span, E, A>): Layer.Layer<Tracer | Exclude<R, Span>, E, A> =>
+    Layer.provide(spanLayer(name, options, ctx), layer)
+
+export const addAttribute = (name: string, value: otel.AttributeValue) =>
+  Effect.flatMap(Span, ({ span }) =>
+    Effect.sync(() => {
+      span.setAttribute(name, value)
+    }),
+  )
+
+export const addAttributes = (attributes: otel.Attributes) =>
+  Effect.flatMap(Span, ({ span }) =>
+    Effect.sync(() => {
+      span.setAttributes(attributes)
+    }),
+  )
+
+export const addAttributesEffect = <R, E>(attributes: Effect.Effect<R, E, otel.Attributes>) =>
+  Effect.flatMap(attributes, (attributes) =>
+    Effect.flatMap(Span, ({ span }) =>
+      Effect.sync(() => {
+        span.setAttributes(attributes)
+      }),
+    ),
+  )
+
+export const addEvent = (
+  name: string,
+  attributesOrStartTime?: otel.SpanAttributes | otel.TimeInput,
+  startTime?: otel.TimeInput,
+) =>
+  Effect.flatMap(Span, ({ span }) =>
+    Effect.sync(() => {
+      span.addEvent(name, attributesOrStartTime, startTime)
+    }),
+  )

package/src/effect/Otel/Tracer.ts

@@ -0,0 +1,30 @@
+import * as Context from '@effect/data/Context'
+import { identity } from '@effect/data/Function'
+import * as Effect from '@effect/io/Effect'
+import * as Layer from '@effect/io/Layer'
+import type * as otel from '@opentelemetry/api'
+
+import { TracerProvider } from './lib-tracer/TracerProvider.js'
+
+export const TracerSymbol = Symbol.for('effect-otel/Tracer')
+export type TracerSymbol = typeof TracerSymbol
+
+export interface Tracer {
+  readonly [TracerSymbol]: TracerSymbol
+  readonly tracer: otel.Tracer
+}
+
+export const Tracer = Context.Tag<Tracer>(TracerSymbol)
+
+export const makeTracer = (name: string) =>
+  Effect.gen(function* ($) {
+    const { tracerProvider } = yield* $(TracerProvider)
+    const tracer = yield* $(Effect.sync(() => tracerProvider.getTracer(name)))
+
+    return identity<Tracer>({
+      [TracerSymbol]: TracerSymbol,
+      tracer,
+    })
+  })
+
+export const LiveTracer = Layer.scoped(Tracer, makeTracer('@effect/otel/Tracer'))

package/src/effect/Otel/index.ts

@@ -0,0 +1,8 @@
+// otel
+export * from './Meter.js'
+export * from './Tracer.js'
+export * from './Span.js'
+export * from './Dummy.js'
+export * from './lib-tracer/BatchSpanProcessor.js'
+export * from './lib-metrics/MetricsProvider.js'
+export * as OTWeb from './lib-tracer/WebProvider.js'

package/src/effect/Otel/lib-metrics/ExporterMetricsOltpGrpc.ts

@@ -0,0 +1,39 @@
+import * as Context from '@effect/data/Context'
+import { pipe } from '@effect/data/Function'
+import * as Effect from '@effect/io/Effect'
+import * as Layer from '@effect/io/Layer'
+import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-grpc'
+import type { OTLPExporterNodeConfigBase } from '@opentelemetry/otlp-exporter-base'
+
+import { PeriodicMetricsProvider } from './PeriodicMetricsProvider.js'
+
+export interface OTLPMetricExporterConfig {
+  readonly _: unique symbol
+}
+
+export const OTLPMetricExporterConfig = Context.Tag<OTLPMetricExporterConfig, OTLPExporterNodeConfigBase>(
+  'otel-metric-exporter-config',
+)
+
+export const makeOTLPMetricExporterConfigLayer = (config: OTLPExporterNodeConfigBase) =>
+  Layer.succeed(OTLPMetricExporterConfig, config)
+
+export const makeMetricExporter = Effect.gen(function* (_) {
+  const config = yield* _(OTLPMetricExporterConfig)
+
+  const metricExporter = yield* _(
+    pipe(
+      Effect.sync(() => new OTLPMetricExporter(config)),
+      Effect.acquireRelease((p) =>
+        pipe(
+          Effect.tryPromise(() => p.shutdown()),
+          Effect.orDie,
+        ),
+      ),
+    ),
+  )
+
+  return metricExporter
+})
+
+export const LivePeriodicMetricsProvider = PeriodicMetricsProvider(makeMetricExporter)