@clayroach/effect 3.19.14-source-capture.8 → 3.19.14-source-trace.1

package/src/internal/metric/registry.ts

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

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