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

package/src/MetricLabel.ts

@@ -0,0 +1,47 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Equal from "./Equal.js"
+import * as internal from "./internal/metric/label.js"
+import type { Pipeable } from "./Pipeable.js"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const MetricLabelTypeId: unique symbol = internal.MetricLabelTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type MetricLabelTypeId = typeof MetricLabelTypeId
+
+/**
+ * A `MetricLabel` represents a key value pair that allows analyzing metrics at
+ * an additional level of granularity.
+ *
+ * For example if a metric tracks the response time of a service labels could
+ * be used to create separate versions that track response times for different
+ * clients.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface MetricLabel extends Equal.Equal, Pipeable {
+  readonly [MetricLabelTypeId]: MetricLabelTypeId
+  readonly key: string
+  readonly value: string
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: (key: string, value: string) => MetricLabel = internal.make
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isMetricLabel: (u: unknown) => u is MetricLabel = internal.isMetricLabel

package/src/MetricPair.ts

@@ -0,0 +1,71 @@
+/**
+ * @since 2.0.0
+ */
+import * as internal from "./internal/metric/pair.js"
+import type * as MetricKey from "./MetricKey.js"
+import type * as MetricKeyType from "./MetricKeyType.js"
+import type * as MetricState from "./MetricState.js"
+import type { Pipeable } from "./Pipeable.js"
+import type * as Types from "./Types.js"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const MetricPairTypeId: unique symbol = internal.MetricPairTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type MetricPairTypeId = typeof MetricPairTypeId
+
+/**
+ * @since 2.0.0
+ * @category model
+ */
+export interface MetricPair<out Type extends MetricKeyType.MetricKeyType<any, any>>
+  extends MetricPair.Variance<Type>, Pipeable
+{
+  readonly metricKey: MetricKey.MetricKey<Type>
+  readonly metricState: MetricState.MetricState<MetricKeyType.MetricKeyType.OutType<Type>>
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace MetricPair {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Untyped extends MetricPair<MetricKeyType.MetricKeyType<any, any>> {}
+
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Variance<out Type extends MetricKeyType.MetricKeyType<any, any>> {
+    readonly [MetricPairTypeId]: {
+      readonly _Type: Types.Covariant<Type>
+    }
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <Type extends MetricKeyType.MetricKeyType<any, any>>(
+  metricKey: MetricKey.MetricKey<Type>,
+  metricState: MetricState.MetricState<MetricKeyType.MetricKeyType.OutType<Type>>
+) => MetricPair.Untyped = internal.make
+
+/**
+ * @since 2.0.0
+ * @category unsafe
+ */
+export const unsafeMake: <Type extends MetricKeyType.MetricKeyType<any, any>>(
+  metricKey: MetricKey.MetricKey<Type>,
+  metricState: MetricState.MetricState.Untyped
+) => MetricPair.Untyped = internal.unsafeMake

package/src/MetricPolling.ts

@@ -0,0 +1,148 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Effect from "./Effect.js"
+import type * as Fiber from "./Fiber.js"
+import * as internal from "./internal/metric/polling.js"
+import type * as Metric from "./Metric.js"
+import type { Pipeable } from "./Pipeable.js"
+import type * as Schedule from "./Schedule.js"
+import type * as Scope from "./Scope.js"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const MetricPollingTypeId: unique symbol = internal.MetricPollingTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type MetricPollingTypeId = typeof MetricPollingTypeId
+
+/**
+ * A `MetricPolling` is a combination of a metric and an effect that polls for
+ * updates to the metric.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface MetricPolling<in out Type, in out In, out R, out E, out Out> extends Pipeable {
+  readonly [MetricPollingTypeId]: MetricPollingTypeId
+  /**
+   * The metric that this `MetricPolling` polls to update.
+   */
+  readonly metric: Metric.Metric<Type, In, Out>
+  /**
+   * An effect that polls a value that may be fed to the metric.
+   */
+  readonly poll: Effect.Effect<In, E, R>
+}
+
+/**
+ * Constructs a new polling metric from a metric and poll effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: <Type, In, Out, R, E>(
+  metric: Metric.Metric<Type, In, Out>,
+  poll: Effect.Effect<In, E, R>
+) => MetricPolling<Type, In, R, E, Out> = internal.make
+
+/**
+ * Collects all of the polling metrics into a single polling metric, which
+ * polls for, updates, and produces the outputs of all individual metrics.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const collectAll: <R, E, Out>(
+  iterable: Iterable<MetricPolling<any, any, R, E, Out>>
+) => MetricPolling<Array<any>, Array<any>, R, E, Array<Out>> = internal.collectAll
+
+/**
+ * Returns an effect that will launch the polling metric in a background
+ * fiber, using the specified schedule.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const launch: {
+  <A2, R2>(
+    schedule: Schedule.Schedule<A2, unknown, R2>
+  ): <Type, In, R, E, Out>(
+    self: MetricPolling<Type, In, R, E, Out>
+  ) => Effect.Effect<Fiber.Fiber<A2, E>, never, R2 | R | Scope.Scope>
+  <Type, In, R, E, Out, A2, R2>(
+    self: MetricPolling<Type, In, R, E, Out>,
+    schedule: Schedule.Schedule<A2, unknown, R2>
+  ): Effect.Effect<Fiber.Fiber<A2, E>, never, Scope.Scope | R | R2>
+} = internal.launch
+
+/**
+ * An effect that polls a value that may be fed to the metric.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const poll: <Type, In, R, E, Out>(self: MetricPolling<Type, In, R, E, Out>) => Effect.Effect<In, E, R> =
+  internal.poll
+
+/**
+ * An effect that polls for a value and uses the value to update the metric.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const pollAndUpdate: <Type, In, R, E, Out>(
+  self: MetricPolling<Type, In, R, E, Out>
+) => Effect.Effect<void, E, R> = internal.pollAndUpdate
+
+/**
+ * Returns a new polling metric whose poll function will be retried with the
+ * specified retry policy.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+export const retry: {
+  <X, E, R2>(
+    policy: Schedule.Schedule<X, NoInfer<E>, R2>
+  ): <Type, In, R, Out>(self: MetricPolling<Type, In, R, E, Out>) => MetricPolling<Type, In, R2 | R, E, Out>
+  <Type, In, R, E, Out, X, R2>(
+    self: MetricPolling<Type, In, R, E, Out>,
+    policy: Schedule.Schedule<X, E, R2>
+  ): MetricPolling<Type, In, R | R2, E, Out>
+} = internal.retry
+
+/**
+ * Zips this polling metric with the specified polling metric.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export const zip: {
+  <Type2, In2, R2, E2, Out2>(
+    that: MetricPolling<Type2, In2, R2, E2, Out2>
+  ): <Type, In, R, E, Out>(
+    self: MetricPolling<Type, In, R, E, Out>
+  ) => MetricPolling<
+    readonly [Type, Type2], // readonly because invariant
+    readonly [In, In2], // readonly because contravariant
+    R2 | R,
+    E2 | E,
+    [Out, Out2]
+  >
+  <Type, In, R, E, Out, Type2, In2, R2, E2, Out2>(
+    self: MetricPolling<Type, In, R, E, Out>,
+    that: MetricPolling<Type2, In2, R2, E2, Out2>
+  ): MetricPolling<
+    readonly [Type, Type2], // readonly because invariant
+    readonly [In, In2], // readonly because contravariant
+    R | R2,
+    E | E2,
+    [Out, Out2]
+  >
+} = internal.zip

package/src/MetricRegistry.ts

@@ -0,0 +1,48 @@
+/**
+ * @since 2.0.0
+ */
+import * as internal from "./internal/metric/registry.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"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const MetricRegistryTypeId: unique symbol = internal.MetricRegistryTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type MetricRegistryTypeId = typeof MetricRegistryTypeId
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface MetricRegistry {
+  readonly [MetricRegistryTypeId]: MetricRegistryTypeId
+  snapshot(): Array<MetricPair.MetricPair.Untyped>
+  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"]>
+  >
+  getCounter<A extends (number | bigint)>(
+    key: MetricKey.MetricKey.Counter<A>
+  ): MetricHook.MetricHook.Counter<A>
+  getFrequency(key: MetricKey.MetricKey.Frequency): MetricHook.MetricHook.Frequency
+  getGauge<A extends (number | bigint)>(key: MetricKey.MetricKey.Gauge<A>): MetricHook.MetricHook.Gauge<A>
+  getHistogram(key: MetricKey.MetricKey.Histogram): MetricHook.MetricHook.Histogram
+  getSummary(key: MetricKey.MetricKey.Summary): MetricHook.MetricHook.Summary
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const make: (_: void) => MetricRegistry = internal.make

package/src/MetricState.ts

@@ -0,0 +1,257 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Equal from "./Equal.js"
+import * as internal from "./internal/metric/state.js"
+import type * as MetricKeyType from "./MetricKeyType.js"
+import type * as Option from "./Option.js"
+import type { Pipeable } from "./Pipeable.js"
+import type * as Types from "./Types.js"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const MetricStateTypeId: unique symbol = internal.MetricStateTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type MetricStateTypeId = typeof MetricStateTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const CounterStateTypeId: unique symbol = internal.CounterStateTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type CounterStateTypeId = typeof CounterStateTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const FrequencyStateTypeId: unique symbol = internal.FrequencyStateTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type FrequencyStateTypeId = typeof FrequencyStateTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const GaugeStateTypeId: unique symbol = internal.GaugeStateTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type GaugeStateTypeId = typeof GaugeStateTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const HistogramStateTypeId: unique symbol = internal.HistogramStateTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type HistogramStateTypeId = typeof HistogramStateTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const SummaryStateTypeId: unique symbol = internal.SummaryStateTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type SummaryStateTypeId = typeof SummaryStateTypeId
+
+/**
+ * A `MetricState` describes the state of a metric. The type parameter of a
+ * metric state corresponds to the type of the metric key (`MetricStateType`).
+ * This phantom type parameter is used to tie keys to their expected states.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface MetricState<in A> extends MetricState.Variance<A>, Equal.Equal, Pipeable {}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace MetricState {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Untyped extends MetricState<any> {}
+
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Counter<in out A extends (number | bigint)>
+    extends MetricState<MetricKeyType.MetricKeyType.Counter<A>>
+  {
+    readonly [CounterStateTypeId]: CounterStateTypeId
+    readonly count: A
+  }
+
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Frequency extends MetricState<MetricKeyType.MetricKeyType.Frequency> {
+    readonly [FrequencyStateTypeId]: FrequencyStateTypeId
+    readonly occurrences: ReadonlyMap<string, number>
+  }
+
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Gauge<in out A extends (number | bigint)> extends MetricState<MetricKeyType.MetricKeyType.Gauge<A>> {
+    readonly [GaugeStateTypeId]: GaugeStateTypeId
+    readonly value: A
+  }
+
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Histogram extends MetricState<MetricKeyType.MetricKeyType.Histogram> {
+    readonly [HistogramStateTypeId]: HistogramStateTypeId
+    readonly buckets: ReadonlyArray<readonly [number, number]>
+    readonly count: number
+    readonly min: number
+    readonly max: number
+    readonly sum: number
+  }
+
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Summary extends MetricState<MetricKeyType.MetricKeyType.Summary> {
+    readonly [SummaryStateTypeId]: SummaryStateTypeId
+    readonly error: number
+    readonly quantiles: ReadonlyArray<readonly [number, Option.Option<number>]>
+    readonly count: number
+    readonly min: number
+    readonly max: number
+    readonly sum: number
+  }
+
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Variance<in A> {
+    readonly [MetricStateTypeId]: {
+      readonly _A: Types.Contravariant<A>
+    }
+  }
+}
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const counter: {
+  (count: number): MetricState.Counter<number>
+  (count: bigint): MetricState.Counter<bigint>
+} = internal.counter
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const frequency: (occurrences: ReadonlyMap<string, number>) => MetricState.Frequency = internal.frequency
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const gauge: {
+  (count: number): MetricState.Gauge<number>
+  (count: bigint): MetricState.Gauge<bigint>
+} = internal.gauge
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+export const histogram: (
+  options: {
+    readonly buckets: ReadonlyArray<readonly [number, number]>
+    readonly count: number
+    readonly min: number
+    readonly max: number
+    readonly sum: number
+  }
+) => MetricState.Histogram = internal.histogram
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+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.Summary = internal.summary
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isMetricState: (u: unknown) => u is MetricState.Counter<number | bigint> = internal.isMetricState
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isCounterState: (u: unknown) => u is MetricState.Counter<number | bigint> = internal.isCounterState
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isFrequencyState: (u: unknown) => u is MetricState.Frequency = internal.isFrequencyState
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isGaugeState: (u: unknown) => u is MetricState.Gauge<number | bigint> = internal.isGaugeState
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isHistogramState: (u: unknown) => u is MetricState.Histogram = internal.isHistogramState
+
+/**
+ * @since 2.0.0
+ * @category refinements
+ */
+export const isSummaryState: (u: unknown) => u is MetricState.Summary = internal.isSummaryState