@livestore/utils 0.0.0 → 0.0.2

package/src/effect/Otel/OtlpHttp.ts

@@ -1,75 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,222 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,8 +0,0 @@
-// 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

@@ -1,39 +0,0 @@
-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)

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

@@ -1,39 +0,0 @@
-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-http'
-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)

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

@@ -1,47 +0,0 @@
-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 type { OTLPExporterNodeConfigBase } from '@opentelemetry/otlp-exporter-base'
-import { WebsocketMetricExporter } from 'otel-websocket-exporter'
-
-import { PeriodicMetricsProvider } from './PeriodicMetricsProvider.js'
-
-export const OTLPMetricExporterConfigSymbol = Symbol.for('otel-metric-exporter-config')
-type OTLPMetricExporterConfigSymbol = typeof OTLPMetricExporterConfigSymbol
-
-export interface OTLPMetricExporterConfig {
-  readonly [OTLPMetricExporterConfigSymbol]: OTLPMetricExporterConfigSymbol
-  readonly config: OTLPExporterNodeConfigBase
-}
-
-export const OTLPMetricExporterConfig = Context.Tag<OTLPMetricExporterConfig>(OTLPMetricExporterConfigSymbol)
-
-export const makeOTLPMetricExporterConfigLayer = (config: OTLPExporterNodeConfigBase) =>
-  Layer.succeed(OTLPMetricExporterConfig, { [OTLPMetricExporterConfigSymbol]: OTLPMetricExporterConfigSymbol, config })
-
-export const makeOTLPMetricExporterConfigLayerM = <R, E>(configEff: Effect.Effect<R, E, OTLPExporterNodeConfigBase>) =>
-  Layer.effect(
-    OTLPMetricExporterConfig,
-    Effect.map(
-      configEff,
-      (config) => ({ [OTLPMetricExporterConfigSymbol]: OTLPMetricExporterConfigSymbol, config }) as const,
-    ),
-  )
-
-export const makeMetricExporter = Effect.gen(function* (_) {
-  const { config } = yield* _(OTLPMetricExporterConfig)
-
-  const metricExporter = yield* _(
-    Effect.acquireRelease(Effect.succeed(new WebsocketMetricExporter(config)), (p) =>
-      pipe(
-        Effect.tryPromise(() => p.shutdown()),
-        Effect.orDie,
-      ),
-    ),
-  )
-
-  return metricExporter
-})
-
-export const LivePeriodicMetricsProvider = PeriodicMetricsProvider(makeMetricExporter)

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

@@ -1,12 +0,0 @@
-import * as Context from '@effect/data/Context'
-import type { MeterProvider } from '@opentelemetry/sdk-metrics'
-
-export const MeterProviderSymbol = Symbol.for('effect-otel/MetricsProvider')
-export type MeterProviderSymbol = typeof MeterProviderSymbol
-
-export interface MetricsProvider {
-  readonly [MeterProviderSymbol]: MeterProviderSymbol
-  readonly metricsProvider: MeterProvider
-}
-
-export const MetricsProvider = Context.Tag<MetricsProvider>(MeterProviderSymbol)

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

@@ -1,77 +0,0 @@
-import * as Context from '@effect/data/Context'
-import { identity, pipe } from '@effect/data/Function'
-import * as Option from '@effect/data/Option'
-import * as Effect from '@effect/io/Effect'
-import * as Layer from '@effect/io/Layer'
-import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-grpc'
-import type { MeterProviderOptions } from '@opentelemetry/sdk-metrics'
-import { MeterProvider, PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics'
-
-import { OTLPMetricExporterConfig } from './ExporterMetricsOltpGrpc.js'
-import { MeterProviderSymbol, MetricsProvider } from './MetricsProvider.js'
-
-export const OTLPMetricsProviderConfigSymbol = Symbol.for('effect-otel/OTLPMetricsProviderConfig')
-
-export interface OTLPMetricsProviderConfig {
-  readonly options: MeterProviderOptions
-}
-
-export const OTLPMetricsProviderConfig = Context.Tag<OTLPMetricsProviderConfig>(OTLPMetricsProviderConfigSymbol)
-
-export const LiveOTLPMetricsProviderConfig = (options: MeterProviderOptions) =>
-  Layer.succeed(OTLPMetricsProviderConfig, { options })
-
-export const makeOTLPMetricsProvider = Effect.gen(function* ($) {
-  const ctx = yield* $(Effect.context<never>())
-
-  const options = pipe(
-    Context.getOption(ctx, OTLPMetricsProviderConfig),
-    Option.map((_) => _.options),
-    Option.getOrUndefined,
-  )
-
-  const metricsProvider = yield* $(Effect.sync(() => new MeterProvider(options)))
-
-  // TODO remove below
-
-  // const metricsExporter = yield* _(exporter)
-  const config = yield* $(OTLPMetricExporterConfig)
-
-  const metricExporter = yield* $(
-    Effect.sync(() => new OTLPMetricExporter(config)),
-    // TODO re-enable
-    Effect.acquireRelease((_p) =>
-      pipe(
-        // Effect.tryPromise(() => p.shutdown()),
-        Effect.unit, // TODO without this I'm seeing a "`config` of undefined" bug
-        Effect.orDie,
-      ),
-    ),
-  )
-
-  const metricReader = yield* $(
-    Effect.sync(
-      () =>
-        new PeriodicExportingMetricReader({
-          exporter: metricExporter,
-          exportIntervalMillis: 1000, // TODO make configurable
-        }),
-    ),
-  )
-
-  yield* $(Effect.sync(() => metricsProvider.addMetricReader(metricReader)))
-
-  // TODO remove above
-
-  return identity<MetricsProvider>({
-    [MeterProviderSymbol]: MeterProviderSymbol,
-    metricsProvider,
-  })
-})
-
-export const OTLPMetricsProviderLayer = Layer.scoped(MetricsProvider, makeOTLPMetricsProvider)
-
-export const OTLPMetricsProvider = (
-  config?: MeterProviderOptions,
-): Layer.Layer<OTLPMetricExporterConfig, never, MetricsProvider> =>
-  config ? Layer.provide(LiveOTLPMetricsProviderConfig(config), OTLPMetricsProviderLayer) : OTLPMetricsProviderLayer