effect 2.0.0-next.44 → 2.0.0-next.46

package/src/MetricLabel.ts

@@ -0,0 +1,47 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Equal from "./Equal"
+import * as internal from "./internal/metric/label"
+import type { Pipeable } from "./Pipeable"
+
+/**
+ * @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,70 @@
+/**
+ * @since 2.0.0
+ */
+import * as internal from "./internal/metric/pair"
+import type * as MetricKey from "./MetricKey"
+import type * as MetricKeyType from "./MetricKeyType"
+import type * as MetricState from "./MetricState"
+import type { Pipeable } from "./Pipeable"
+
+/**
+ * @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<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<Type extends MetricKeyType.MetricKeyType<any, any>> {
+    readonly [MetricPairTypeId]: {
+      readonly _Type: (_: never) => 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,136 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Effect from "./Effect"
+import type * as Fiber from "./Fiber"
+import * as internal from "./internal/metric/polling"
+import type * as Metric from "./Metric"
+import type { Pipeable } from "./Pipeable"
+import type * as Schedule from "./Schedule"
+import type * as Scope from "./Scope"
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export const PollingMetricTypeId: unique symbol = internal.PollingMetricTypeId
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+export type PollingMetricTypeId = typeof PollingMetricTypeId
+
+/**
+ * A `PollingMetric` is a combination of a metric and an effect that polls for
+ * updates to the metric.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export interface PollingMetric<Type, In, R, E, Out> extends Pipeable {
+  readonly [PollingMetricTypeId]: PollingMetricTypeId
+  /**
+   * The metric that this `PollingMetric` 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<R, E, In>
+}
+
+/**
+ * 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<R, E, In>
+) => PollingMetric<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<PollingMetric<any, any, R, E, Out>>
+) => PollingMetric<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: {
+  <R2, A2>(
+    schedule: Schedule.Schedule<R2, unknown, A2>
+  ): <Type, In, R, E, Out>(
+    self: PollingMetric<Type, In, R, E, Out>
+  ) => Effect.Effect<R2 | R | Scope.Scope, never, Fiber.Fiber<E, A2>>
+  <Type, In, R, E, Out, R2, A2>(
+    self: PollingMetric<Type, In, R, E, Out>,
+    schedule: Schedule.Schedule<R2, unknown, A2>
+  ): Effect.Effect<Scope.Scope | R | R2, never, Fiber.Fiber<E, A2>>
+} = 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: PollingMetric<Type, In, R, E, Out>) => Effect.Effect<R, E, In> =
+  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: PollingMetric<Type, In, R, E, Out>
+) => Effect.Effect<R, E, void> = 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: {
+  <R2, E, _>(
+    policy: Schedule.Schedule<R2, E, _>
+  ): <Type, In, R, Out>(self: PollingMetric<Type, In, R, E, Out>) => PollingMetric<Type, In, R2 | R, E, Out>
+  <Type, In, R, Out, R2, E, _>(
+    self: PollingMetric<Type, In, R, E, Out>,
+    policy: Schedule.Schedule<R2, E, _>
+  ): PollingMetric<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: PollingMetric<Type2, In2, R2, E2, Out2>
+  ): <Type, In, R, E, Out>(
+    self: PollingMetric<Type, In, R, E, Out>
+  ) => PollingMetric<readonly [Type, Type2], readonly [In, In2], R2 | R, E2 | E, readonly [Out, Out2]>
+  <Type, In, R, E, Out, Type2, In2, R2, E2, Out2>(
+    self: PollingMetric<Type, In, R, E, Out>,
+    that: PollingMetric<Type2, In2, R2, E2, Out2>
+  ): PollingMetric<readonly [Type, Type2], readonly [In, In2], R | R2, E | E2, readonly [Out, Out2]>
+} = internal.zip

package/src/MetricRegistry.ts

@@ -0,0 +1,47 @@
+/**
+ * @since 2.0.0
+ */
+import type * as HashSet from "./HashSet"
+import * as internal from "./internal/metric/registry"
+import type * as MetricHook from "./MetricHook"
+import type * as MetricKey from "./MetricKey"
+import type * as MetricKeyType from "./MetricKeyType"
+import type * as MetricPair from "./MetricPair"
+
+/**
+ * @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(): HashSet.HashSet<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,256 @@
+/**
+ * @since 2.0.0
+ */
+import type * as Chunk from "./Chunk"
+import type * as Equal from "./Equal"
+import type * as HashMap from "./HashMap"
+import * as internal from "./internal/metric/state"
+import type * as MetricKeyType from "./MetricKeyType"
+import type * as Option from "./Option"
+import type { Pipeable } from "./Pipeable"
+
+/**
+ * @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<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<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: HashMap.HashMap<string, number>
+  }
+
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Gauge<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: Chunk.Chunk<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: Chunk.Chunk<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<A> {
+    readonly [MetricStateTypeId]: {
+      readonly _A: (_: A) => void
+    }
+  }
+}
+
+/**
+ * @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: HashMap.HashMap<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: Chunk.Chunk<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: Chunk.Chunk<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