@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/internal/metric/registry.ts

@@ -1,187 +0,0 @@
-import { pipe } from "../../Function.js"
-import type * as MetricHook from "../../MetricHook.js"
-import type * as MetricKey from "../../MetricKey.js"
-import type * as MetricKeyType from "../../MetricKeyType.js"
-import type * as MetricPair from "../../MetricPair.js"
-import type * as MetricRegistry from "../../MetricRegistry.js"
-import * as MutableHashMap from "../../MutableHashMap.js"
-import * as Option from "../../Option.js"
-import * as metricHook from "./hook.js"
-import * as metricKeyType from "./keyType.js"
-import * as metricPair from "./pair.js"
-
-/** @internal */
-const MetricRegistrySymbolKey = "effect/MetricRegistry"
-
-/** @internal */
-export const MetricRegistryTypeId: MetricRegistry.MetricRegistryTypeId = Symbol.for(
-  MetricRegistrySymbolKey
-) as MetricRegistry.MetricRegistryTypeId
-
-/** @internal */
-class MetricRegistryImpl implements MetricRegistry.MetricRegistry {
-  readonly [MetricRegistryTypeId]: MetricRegistry.MetricRegistryTypeId = MetricRegistryTypeId
-
-  private map = MutableHashMap.empty<
-    MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>,
-    MetricHook.MetricHook.Root
-  >()
-
-  snapshot(): Array<MetricPair.MetricPair.Untyped> {
-    const result: Array<MetricPair.MetricPair.Untyped> = []
-    for (const [key, hook] of this.map) {
-      result.push(metricPair.unsafeMake(key, hook.get()))
-    }
-    return result
-  }
-
-  get<Type extends MetricKeyType.MetricKeyType<any, any>>(
-    key: MetricKey.MetricKey<Type>
-  ): MetricHook.MetricHook<
-    MetricKeyType.MetricKeyType.InType<typeof key["keyType"]>,
-    MetricKeyType.MetricKeyType.OutType<typeof key["keyType"]>
-  > {
-    const hook = pipe(
-      this.map,
-      MutableHashMap.get(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>),
-      Option.getOrUndefined
-    )
-    if (hook == null) {
-      if (metricKeyType.isCounterKey(key.keyType)) {
-        return this.getCounter(key as unknown as MetricKey.MetricKey.Counter<any>) as any
-      }
-      if (metricKeyType.isGaugeKey(key.keyType)) {
-        return this.getGauge(key as unknown as MetricKey.MetricKey.Gauge<any>) as any
-      }
-      if (metricKeyType.isFrequencyKey(key.keyType)) {
-        return this.getFrequency(key as unknown as MetricKey.MetricKey.Frequency) as any
-      }
-      if (metricKeyType.isHistogramKey(key.keyType)) {
-        return this.getHistogram(key as unknown as MetricKey.MetricKey.Histogram) as any
-      }
-      if (metricKeyType.isSummaryKey(key.keyType)) {
-        return this.getSummary(key as unknown as MetricKey.MetricKey.Summary) as any
-      }
-      throw new Error(
-        "BUG: MetricRegistry.get - unknown MetricKeyType - please report an issue at https://github.com/Effect-TS/effect/issues"
-      )
-    } else {
-      return hook as any
-    }
-  }
-
-  getCounter<A extends (number | bigint)>(key: MetricKey.MetricKey.Counter<A>): MetricHook.MetricHook.Counter<A> {
-    let value = pipe(
-      this.map,
-      MutableHashMap.get(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>),
-      Option.getOrUndefined
-    )
-    if (value == null) {
-      const counter = metricHook.counter(key)
-      if (!pipe(this.map, MutableHashMap.has(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>))) {
-        pipe(
-          this.map,
-          MutableHashMap.set(
-            key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>,
-            counter as MetricHook.MetricHook.Root
-          )
-        )
-      }
-      value = counter
-    }
-    return value as MetricHook.MetricHook.Counter<A>
-  }
-
-  getFrequency(key: MetricKey.MetricKey.Frequency): MetricHook.MetricHook.Frequency {
-    let value = pipe(
-      this.map,
-      MutableHashMap.get(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>),
-      Option.getOrUndefined
-    )
-    if (value == null) {
-      const frequency = metricHook.frequency(key)
-      if (!pipe(this.map, MutableHashMap.has(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>))) {
-        pipe(
-          this.map,
-          MutableHashMap.set(
-            key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>,
-            frequency as MetricHook.MetricHook.Root
-          )
-        )
-      }
-      value = frequency
-    }
-    return value as MetricHook.MetricHook.Frequency
-  }
-
-  getGauge<A extends (number | bigint)>(key: MetricKey.MetricKey.Gauge<A>): MetricHook.MetricHook.Gauge<A> {
-    let value = pipe(
-      this.map,
-      MutableHashMap.get(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>),
-      Option.getOrUndefined
-    )
-    if (value == null) {
-      const gauge = metricHook.gauge(key as any, key.keyType.bigint ? BigInt(0) as any : 0)
-      if (!pipe(this.map, MutableHashMap.has(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>))) {
-        pipe(
-          this.map,
-          MutableHashMap.set(
-            key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>,
-            gauge as MetricHook.MetricHook.Root
-          )
-        )
-      }
-      value = gauge
-    }
-    return value as MetricHook.MetricHook.Gauge<A>
-  }
-
-  getHistogram(key: MetricKey.MetricKey.Histogram): MetricHook.MetricHook.Histogram {
-    let value = pipe(
-      this.map,
-      MutableHashMap.get(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>),
-      Option.getOrUndefined
-    )
-    if (value == null) {
-      const histogram = metricHook.histogram(key)
-      if (!pipe(this.map, MutableHashMap.has(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>))) {
-        pipe(
-          this.map,
-          MutableHashMap.set(
-            key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>,
-            histogram as MetricHook.MetricHook.Root
-          )
-        )
-      }
-      value = histogram
-    }
-    return value as MetricHook.MetricHook.Histogram
-  }
-
-  getSummary(key: MetricKey.MetricKey.Summary): MetricHook.MetricHook.Summary {
-    let value = pipe(
-      this.map,
-      MutableHashMap.get(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>),
-      Option.getOrUndefined
-    )
-    if (value == null) {
-      const summary = metricHook.summary(key)
-      if (!pipe(this.map, MutableHashMap.has(key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>))) {
-        pipe(
-          this.map,
-          MutableHashMap.set(
-            key as MetricKey.MetricKey<MetricKeyType.MetricKeyType.Untyped>,
-            summary as MetricHook.MetricHook.Root
-          )
-        )
-      }
-      value = summary
-    }
-    return value as MetricHook.MetricHook.Summary
-  }
-}
-
-/** @internal */
-export const make = (): MetricRegistry.MetricRegistry => {
-  return new MetricRegistryImpl()
-}

package/src/internal/metric/state.ts

@@ -1,290 +0,0 @@
-import * as Arr from "../../Array.js"
-import * as Equal from "../../Equal.js"
-import { pipe } from "../../Function.js"
-import * as Hash from "../../Hash.js"
-import type * as MetricState from "../../MetricState.js"
-import type * as Option from "../../Option.js"
-import { pipeArguments } from "../../Pipeable.js"
-import { hasProperty } from "../../Predicate.js"
-
-/** @internal */
-const MetricStateSymbolKey = "effect/MetricState"
-
-/** @internal */
-export const MetricStateTypeId: MetricState.MetricStateTypeId = Symbol.for(
-  MetricStateSymbolKey
-) as MetricState.MetricStateTypeId
-
-/** @internal */
-const CounterStateSymbolKey = "effect/MetricState/Counter"
-
-/** @internal */
-export const CounterStateTypeId: MetricState.CounterStateTypeId = Symbol.for(
-  CounterStateSymbolKey
-) as MetricState.CounterStateTypeId
-
-/** @internal */
-const FrequencyStateSymbolKey = "effect/MetricState/Frequency"
-
-/** @internal */
-export const FrequencyStateTypeId: MetricState.FrequencyStateTypeId = Symbol.for(
-  FrequencyStateSymbolKey
-) as MetricState.FrequencyStateTypeId
-
-/** @internal */
-const GaugeStateSymbolKey = "effect/MetricState/Gauge"
-
-/** @internal */
-export const GaugeStateTypeId: MetricState.GaugeStateTypeId = Symbol.for(
-  GaugeStateSymbolKey
-) as MetricState.GaugeStateTypeId
-
-/** @internal */
-const HistogramStateSymbolKey = "effect/MetricState/Histogram"
-
-/** @internal */
-export const HistogramStateTypeId: MetricState.HistogramStateTypeId = Symbol.for(
-  HistogramStateSymbolKey
-) as MetricState.HistogramStateTypeId
-
-/** @internal */
-const SummaryStateSymbolKey = "effect/MetricState/Summary"
-
-/** @internal */
-export const SummaryStateTypeId: MetricState.SummaryStateTypeId = Symbol.for(
-  SummaryStateSymbolKey
-) as MetricState.SummaryStateTypeId
-
-const metricStateVariance = {
-  /* c8 ignore next */
-  _A: (_: unknown) => _
-}
-
-/** @internal */
-class CounterState<A extends (number | bigint)> implements MetricState.MetricState.Counter<A> {
-  readonly [MetricStateTypeId] = metricStateVariance
-  readonly [CounterStateTypeId]: MetricState.CounterStateTypeId = CounterStateTypeId
-  constructor(readonly count: A) {}
-  [Hash.symbol](): number {
-    return pipe(
-      Hash.hash(CounterStateSymbolKey),
-      Hash.combine(Hash.hash(this.count)),
-      Hash.cached(this)
-    )
-  }
-  [Equal.symbol](that: unknown): boolean {
-    return isCounterState(that) && this.count === that.count
-  }
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-const arrayEquals = Arr.getEquivalence(Equal.equals)
-
-/** @internal */
-class FrequencyState implements MetricState.MetricState.Frequency {
-  readonly [MetricStateTypeId] = metricStateVariance
-  readonly [FrequencyStateTypeId]: MetricState.FrequencyStateTypeId = FrequencyStateTypeId
-  constructor(readonly occurrences: ReadonlyMap<string, number>) {}
-  _hash: number | undefined;
-  [Hash.symbol](): number {
-    return pipe(
-      Hash.string(FrequencyStateSymbolKey),
-      Hash.combine(Hash.array(Arr.fromIterable(this.occurrences.entries()))),
-      Hash.cached(this)
-    )
-  }
-  [Equal.symbol](that: unknown): boolean {
-    return isFrequencyState(that) && arrayEquals(
-      Arr.fromIterable(this.occurrences.entries()),
-      Arr.fromIterable(that.occurrences.entries())
-    )
-  }
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-/** @internal */
-class GaugeState<A extends (number | bigint)> implements MetricState.MetricState.Gauge<A> {
-  readonly [MetricStateTypeId] = metricStateVariance
-  readonly [GaugeStateTypeId]: MetricState.GaugeStateTypeId = GaugeStateTypeId
-  constructor(readonly value: A) {}
-  [Hash.symbol](): number {
-    return pipe(
-      Hash.hash(GaugeStateSymbolKey),
-      Hash.combine(Hash.hash(this.value)),
-      Hash.cached(this)
-    )
-  }
-  [Equal.symbol](u: unknown): boolean {
-    return isGaugeState(u) && this.value === u.value
-  }
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-/** @internal */
-export class HistogramState implements MetricState.MetricState.Histogram {
-  readonly [MetricStateTypeId] = metricStateVariance
-  readonly [HistogramStateTypeId]: MetricState.HistogramStateTypeId = HistogramStateTypeId
-  constructor(
-    readonly buckets: ReadonlyArray<readonly [number, number]>,
-    readonly count: number,
-    readonly min: number,
-    readonly max: number,
-    readonly sum: number
-  ) {}
-  [Hash.symbol](): number {
-    return pipe(
-      Hash.hash(HistogramStateSymbolKey),
-      Hash.combine(Hash.hash(this.buckets)),
-      Hash.combine(Hash.hash(this.count)),
-      Hash.combine(Hash.hash(this.min)),
-      Hash.combine(Hash.hash(this.max)),
-      Hash.combine(Hash.hash(this.sum)),
-      Hash.cached(this)
-    )
-  }
-  [Equal.symbol](that: unknown): boolean {
-    return isHistogramState(that) &&
-      Equal.equals(this.buckets, that.buckets) &&
-      this.count === that.count &&
-      this.min === that.min &&
-      this.max === that.max &&
-      this.sum === that.sum
-  }
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-/** @internal */
-export class SummaryState implements MetricState.MetricState.Summary {
-  readonly [MetricStateTypeId] = metricStateVariance
-  readonly [SummaryStateTypeId]: MetricState.SummaryStateTypeId = SummaryStateTypeId
-  constructor(
-    readonly error: number,
-    readonly quantiles: ReadonlyArray<readonly [number, Option.Option<number>]>,
-    readonly count: number,
-    readonly min: number,
-    readonly max: number,
-    readonly sum: number
-  ) {}
-  [Hash.symbol](): number {
-    return pipe(
-      Hash.hash(SummaryStateSymbolKey),
-      Hash.combine(Hash.hash(this.error)),
-      Hash.combine(Hash.hash(this.quantiles)),
-      Hash.combine(Hash.hash(this.count)),
-      Hash.combine(Hash.hash(this.min)),
-      Hash.combine(Hash.hash(this.max)),
-      Hash.combine(Hash.hash(this.sum)),
-      Hash.cached(this)
-    )
-  }
-  [Equal.symbol](that: unknown): boolean {
-    return isSummaryState(that) &&
-      this.error === that.error &&
-      Equal.equals(this.quantiles, that.quantiles) &&
-      this.count === that.count &&
-      this.min === that.min &&
-      this.max === that.max &&
-      this.sum === that.sum
-  }
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-/** @internal */
-export const counter: {
-  (count: number): MetricState.MetricState.Counter<number>
-  (count: bigint): MetricState.MetricState.Counter<bigint>
-} = (count) => new CounterState(count) as any
-
-/** @internal */
-export const frequency = (occurrences: ReadonlyMap<string, number>): MetricState.MetricState.Frequency => {
-  return new FrequencyState(occurrences)
-}
-
-/** @internal */
-export const gauge: {
-  (count: number): MetricState.MetricState.Gauge<number>
-  (count: bigint): MetricState.MetricState.Gauge<bigint>
-} = (count) => new GaugeState(count) as any
-
-/** @internal */
-export const histogram = (
-  options: {
-    readonly buckets: ReadonlyArray<readonly [number, number]>
-    readonly count: number
-    readonly min: number
-    readonly max: number
-    readonly sum: number
-  }
-): MetricState.MetricState.Histogram =>
-  new HistogramState(
-    options.buckets,
-    options.count,
-    options.min,
-    options.max,
-    options.sum
-  )
-
-/** @internal */
-export const summary = (
-  options: {
-    readonly error: number
-    readonly quantiles: ReadonlyArray<readonly [number, Option.Option<number>]>
-    readonly count: number
-    readonly min: number
-    readonly max: number
-    readonly sum: number
-  }
-): MetricState.MetricState.Summary =>
-  new SummaryState(
-    options.error,
-    options.quantiles,
-    options.count,
-    options.min,
-    options.max,
-    options.sum
-  )
-
-/** @internal */
-export const isMetricState = (u: unknown): u is MetricState.MetricState.Counter<number | bigint> =>
-  hasProperty(u, MetricStateTypeId)
-
-/** @internal */
-export const isCounterState = (u: unknown): u is MetricState.MetricState.Counter<number | bigint> =>
-  hasProperty(u, CounterStateTypeId)
-
-/**
- * @since 2.0.0
- * @category refinements
- */
-export const isFrequencyState = (u: unknown): u is MetricState.MetricState.Frequency =>
-  hasProperty(u, FrequencyStateTypeId)
-
-/**
- * @since 2.0.0
- * @category refinements
- */
-export const isGaugeState = (u: unknown): u is MetricState.MetricState.Gauge<number | bigint> =>
-  hasProperty(u, GaugeStateTypeId)
-
-/**
- * @since 2.0.0
- * @category refinements
- */
-export const isHistogramState = (u: unknown): u is MetricState.MetricState.Histogram =>
-  hasProperty(u, HistogramStateTypeId)
-
-/**
- * @since 2.0.0
- * @category refinements
- */
-export const isSummaryState = (u: unknown): u is MetricState.MetricState.Summary => hasProperty(u, SummaryStateTypeId)