@livestore/utils 0.0.0

package/src/effect/Otel/lib-metrics/ExporterMetricsOltpHttp.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-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

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

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

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

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

@@ -0,0 +1,77 @@
+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-http'
+import type { MeterProviderOptions } from '@opentelemetry/sdk-metrics'
+import { MeterProvider, PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics'
+
+import { OTLPMetricExporterConfig } from './ExporterMetricsOltpHttp.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

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

@@ -0,0 +1,80 @@
+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-http'
+import type { MeterProviderOptions } from '@opentelemetry/sdk-metrics'
+import { MeterProvider, PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics'
+import { WebsocketMetricExporter } from 'otel-websocket-exporter'
+
+import { OTLPMetricExporterConfig } from './ExporterMetricsOltpWebsocket.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* $(
+    pipe(
+      Effect.sync(() => new WebsocketMetricExporter(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

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

@@ -0,0 +1,55 @@
+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 Scope from '@effect/io/Scope'
+import type { MetricReader, PushMetricExporter } from '@opentelemetry/sdk-metrics'
+import { PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics'
+
+import { MetricsProvider } from './MetricsProvider.js'
+
+//
+// Span Processor
+//
+
+export const PeriodicMetricsProviderSymbol = Symbol.for('effect-otel/PeriodicMetricsProvider')
+export type PeriodicMetricsProviderSymbol = typeof PeriodicMetricsProviderSymbol
+
+export interface PeriodicMetricsProvider {
+  readonly [PeriodicMetricsProviderSymbol]: PeriodicMetricsProviderSymbol
+  readonly metricsExporter: PushMetricExporter
+  readonly metricReader: MetricReader
+}
+
+export const makePeriodicMetricsProvider = <R, E, A extends PushMetricExporter>(
+  exporter: Effect.Effect<R | Scope.Scope, E, A>,
+) =>
+  Effect.gen(function* ($) {
+    const { metricsProvider } = yield* $(MetricsProvider)
+
+    const metricsExporter = yield* $(exporter)
+
+    const metricReader = yield* $(
+      Effect.sync(
+        () =>
+          new PeriodicExportingMetricReader({
+            exporter: metricsExporter,
+            exportIntervalMillis: 1000, // TODO make configurable
+          }),
+      ),
+    )
+
+    yield* $(Effect.sync(() => metricsProvider.addMetricReader(metricReader)))
+
+    return identity<PeriodicMetricsProvider>({
+      [PeriodicMetricsProviderSymbol]: PeriodicMetricsProviderSymbol,
+      metricsExporter,
+      metricReader,
+    })
+  })
+
+export const PeriodicMetricsProviderTag = Context.Tag<PeriodicMetricsProvider>(PeriodicMetricsProviderSymbol)
+
+export const PeriodicMetricsProvider = <R, E, A extends PushMetricExporter>(
+  exporter: Effect.Effect<R | Scope.Scope, E, A>,
+) => Layer.scoped(PeriodicMetricsProviderTag, makePeriodicMetricsProvider(exporter))

package/src/effect/Otel/lib-tracer/BatchSpanProcessor.ts

@@ -0,0 +1,58 @@
+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 Scope from '@effect/io/Scope'
+import type { SpanExporter } from '@opentelemetry/sdk-trace-base'
+import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base'
+
+import { TracerProvider } from './TracerProvider.js'
+
+//
+// Span Processor
+//
+
+export const BatchProcessorSymbol = Symbol.for('effect-otel/BatchProcessor')
+export type BatchProcessorSymbol = typeof BatchProcessorSymbol
+
+export interface BatchProcessor {
+  readonly [BatchProcessorSymbol]: BatchProcessorSymbol
+  readonly spanExporter: SpanExporter
+  readonly spanProcessor: BatchSpanProcessor
+}
+
+export const makeBatchProcessor = <R, E, A extends SpanExporter>(exporter: Effect.Effect<R | Scope.Scope, E, A>) =>
+  Effect.gen(function* ($) {
+    const { tracerProvider } = yield* $(TracerProvider)
+
+    const spanExporter = yield* $(exporter)
+
+    const spanProcessor = yield* $(
+      Effect.sync(
+        () =>
+          new BatchSpanProcessor(
+            spanExporter,
+            // TODO make this configurable
+            {
+              scheduledDelayMillis: 500,
+              maxExportBatchSize: 1000,
+              maxQueueSize: 10_000_000,
+              exportTimeoutMillis: 1000 * 60 * 3, // 3 minutes
+            },
+          ),
+      ),
+    )
+
+    yield* $(Effect.sync(() => tracerProvider.addSpanProcessor(spanProcessor)))
+
+    return identity<BatchProcessor>({
+      [BatchProcessorSymbol]: BatchProcessorSymbol,
+      spanExporter,
+      spanProcessor,
+    })
+  })
+
+export const BatchProcessorTag = Context.Tag<BatchProcessor>(BatchProcessorSymbol)
+
+export const BatchProcessor = <R, E, A extends SpanExporter>(exporter: Effect.Effect<R | Scope.Scope, E, A>) =>
+  Layer.scoped(BatchProcessorTag, makeBatchProcessor(exporter))

package/src/effect/Otel/lib-tracer/ExporterTraceOtlpGrpc.ts

@@ -0,0 +1,64 @@
+import * as Context from '@effect/data/Context'
+import * as Duration from '@effect/data/Duration'
+import { pipe } from '@effect/data/Function'
+import * as Effect from '@effect/io/Effect'
+import * as Layer from '@effect/io/Layer'
+import { diag, DiagConsoleLogger, DiagLogLevel } from '@opentelemetry/api'
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc'
+import type { OTLPExporterNodeConfigBase } from '@opentelemetry/otlp-exporter-base'
+
+import { SimpleProcessor } from './SimpleProcessor.js'
+
+export const OTLPTraceExporterConfigSymbol = Symbol.for('effect-otel/OTLPTraceExporterConfig')
+type OTLPTraceExporterConfigSymbol = typeof OTLPTraceExporterConfigSymbol
+
+export interface OTLPTraceExporterConfig {
+  readonly [OTLPTraceExporterConfigSymbol]: OTLPTraceExporterConfigSymbol
+  readonly config: OTLPExporterNodeConfigBase
+}
+
+export const OTLPTraceExporterConfig = Context.Tag<OTLPTraceExporterConfig>(OTLPTraceExporterConfigSymbol)
+
+export const makeOTLPTraceExporterConfigLayer = (config: OTLPExporterNodeConfigBase) =>
+  Layer.succeed(OTLPTraceExporterConfig, { [OTLPTraceExporterConfigSymbol]: OTLPTraceExporterConfigSymbol, config })
+
+export const makeOTLPTraceExporterConfigLayerM = <R, E>(configEff: Effect.Effect<R, E, OTLPExporterNodeConfigBase>) =>
+  Layer.effect(
+    OTLPTraceExporterConfig,
+    Effect.map(
+      configEff,
+      (config) => ({ [OTLPTraceExporterConfigSymbol]: OTLPTraceExporterConfigSymbol, config }) as const,
+    ),
+  )
+export const makeTracingSpanExporter = Effect.gen(function* ($) {
+  const { config } = yield* $(OTLPTraceExporterConfig)
+
+  diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.ERROR)
+
+  const spanExporter = yield* $(
+    pipe(
+      Effect.sync(() => new OTLPTraceExporter(config)),
+      // NOTE Unfortunately this workaround/"hack" is currently needed since Otel doesn't yet provide a graceful
+      // way to shutdown.
+      //
+      // Related issue: https://github.com/open-telemetry/opentelemetry-js/issues/987
+      Effect.acquireRelease((p) =>
+        Effect.gen(function* ($) {
+          while (1) {
+            yield* $(Effect.sleep(Duration.millis(0)))
+            const promises = p['_sendingPromises'] as any[]
+            if (promises.length > 0) {
+              yield* $(Effect.exit(Effect.promise(() => Promise.all(promises))))
+            } else {
+              break
+            }
+          }
+        }),
+      ),
+    ),
+  )
+
+  return spanExporter
+})
+
+export const LiveSimpleProcessor = SimpleProcessor(makeTracingSpanExporter)

package/src/effect/Otel/lib-tracer/ExporterTraceOtlpHttp.ts

@@ -0,0 +1,64 @@
+import * as Context from '@effect/data/Context'
+import * as Duration from '@effect/data/Duration'
+import { pipe } from '@effect/data/Function'
+import * as Effect from '@effect/io/Effect'
+import * as Layer from '@effect/io/Layer'
+import { diag, DiagConsoleLogger, DiagLogLevel } from '@opentelemetry/api'
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'
+import type { OTLPExporterNodeConfigBase } from '@opentelemetry/otlp-exporter-base'
+
+import { SimpleProcessor } from './SimpleProcessor.js'
+
+export const OTLPTraceExporterConfigSymbol = Symbol.for('effect-otel/OTLPTraceExporterConfig')
+type OTLPTraceExporterConfigSymbol = typeof OTLPTraceExporterConfigSymbol
+
+export interface OTLPTraceExporterConfig {
+  readonly [OTLPTraceExporterConfigSymbol]: OTLPTraceExporterConfigSymbol
+  readonly config: OTLPExporterNodeConfigBase
+}
+
+export const OTLPTraceExporterConfig = Context.Tag<OTLPTraceExporterConfig>(OTLPTraceExporterConfigSymbol)
+
+export const makeOTLPTraceExporterConfigLayer = (config: OTLPExporterNodeConfigBase) =>
+  Layer.succeed(OTLPTraceExporterConfig, { [OTLPTraceExporterConfigSymbol]: OTLPTraceExporterConfigSymbol, config })
+
+export const makeOTLPTraceExporterConfigLayerM = <R, E>(configEff: Effect.Effect<R, E, OTLPExporterNodeConfigBase>) =>
+  Layer.effect(
+    OTLPTraceExporterConfig,
+    Effect.map(
+      configEff,
+      (config) => ({ [OTLPTraceExporterConfigSymbol]: OTLPTraceExporterConfigSymbol, config }) as const,
+    ),
+  )
+export const makeTracingSpanExporter = Effect.gen(function* ($) {
+  const { config } = yield* $(OTLPTraceExporterConfig)
+
+  diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.ERROR)
+
+  const spanExporter = yield* $(
+    pipe(
+      Effect.sync(() => new OTLPTraceExporter(config)),
+      // NOTE Unfortunately this workaround/"hack" is currently needed since Otel doesn't yet provide a graceful
+      // way to shutdown.
+      //
+      // Related issue: https://github.com/open-telemetry/opentelemetry-js/issues/987
+      Effect.acquireRelease((p) =>
+        Effect.gen(function* ($) {
+          while (1) {
+            yield* $(Effect.sleep(Duration.millis(0)))
+            const promises = p['_sendingPromises'] as any[]
+            if (promises.length > 0) {
+              yield* $(Effect.exit(Effect.promise(() => Promise.all(promises))))
+            } else {
+              break
+            }
+          }
+        }),
+      ),
+    ),
+  )
+
+  return spanExporter
+})
+
+export const LiveSimpleProcessor = SimpleProcessor(makeTracingSpanExporter)

package/src/effect/Otel/lib-tracer/ExporterTraceOtlpWebsocket.ts

@@ -0,0 +1,38 @@
+import * as Context from '@effect/data/Context'
+import * as Duration from '@effect/data/Duration'
+import * as Effect from '@effect/io/Effect'
+import * as Layer from '@effect/io/Layer'
+import type { OTLPExporterNodeConfigBase } from '@opentelemetry/otlp-exporter-base'
+import { WebsocketTraceExporter } from 'otel-websocket-exporter'
+
+export const OTLPTraceExporterConfig = Context.Tag<OTLPExporterNodeConfigBase>('effect-otel/OTLPTraceExporterConfig')
+
+export const makeOTLPTraceExporterConfigLayer = (config: OTLPExporterNodeConfigBase) =>
+  Layer.succeed(OTLPTraceExporterConfig, config)
+
+export const makeTracingSpanExporter = Effect.gen(function* ($) {
+  const config = yield* $(OTLPTraceExporterConfig)
+
+  const spanExporter = yield* $(
+    Effect.sync(() => new WebsocketTraceExporter(config)),
+    // NOTE Unfortunately this workaround/"hack" is currently needed since Otel doesn't yet provide a graceful
+    // way to shutdown.
+    //
+    // Related issue: https://github.com/open-telemetry/opentelemetry-js/issues/987
+    Effect.acquireRelease((p) =>
+      Effect.gen(function* ($) {
+        while (1) {
+          yield* $(Effect.sleep(Duration.millis(0)))
+          const promises = p['_sendingPromises'] as any[]
+          if (promises.length > 0) {
+            yield* $(Effect.exit(Effect.promise(() => Promise.all(promises))))
+          } else {
+            break
+          }
+        }
+      }),
+    ),
+  )
+
+  return spanExporter
+})

package/src/effect/Otel/lib-tracer/README.md

@@ -0,0 +1 @@
+The files in this folder should be contributed back into effect/otel.

package/src/effect/Otel/lib-tracer/SimpleProcessor.ts

@@ -0,0 +1,46 @@
+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 Scope from '@effect/io/Scope'
+import type { SpanExporter } from '@opentelemetry/sdk-trace-base'
+import { ConsoleSpanExporter, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base'
+
+import { TracerProvider } from './TracerProvider.js'
+
+//
+// Span Processor
+//
+
+export const SimpleProcessorSymbol = Symbol.for('effect-otel/SimpleProcessor')
+export type SimpleProcessorSymbol = typeof SimpleProcessorSymbol
+
+export interface SimpleProcessor {
+  readonly [SimpleProcessorSymbol]: SimpleProcessorSymbol
+  readonly spanExporter: SpanExporter
+  readonly spanProcessor: SimpleSpanProcessor
+}
+
+export const makeSimpleProcessor = <R, E, A extends SpanExporter>(exporter: Effect.Effect<R | Scope.Scope, E, A>) =>
+  Effect.gen(function* ($) {
+    const { tracerProvider } = yield* $(TracerProvider)
+
+    const spanExporter = yield* $(exporter)
+
+    const spanProcessor = yield* $(Effect.sync(() => new SimpleSpanProcessor(spanExporter)))
+
+    yield* $(Effect.sync(() => tracerProvider.addSpanProcessor(spanProcessor)))
+
+    return identity<SimpleProcessor>({
+      [SimpleProcessorSymbol]: SimpleProcessorSymbol,
+      spanExporter,
+      spanProcessor,
+    })
+  })
+
+export const SimpleProcessorTag = Context.Tag<SimpleProcessor>(SimpleProcessorSymbol)
+
+export const SimpleProcessor = <R, E, A extends SpanExporter>(exporter: Effect.Effect<R | Scope.Scope, E, A>) =>
+  Layer.scoped(SimpleProcessorTag, makeSimpleProcessor(exporter))
+
+export const LiveConsoleSimple = SimpleProcessor(Effect.sync(() => new ConsoleSpanExporter()))