effect 3.6.4 → 3.6.5

package/src/internal/metric/hook.ts

@@ -30,6 +30,7 @@ export const make = <In, Out>(
   options: {
     readonly get: LazyArg<Out>
     readonly update: (input: In) => void
+    readonly modify: (input: In) => void
   }
 ): MetricHook.MetricHook<In, Out> => ({
   [MetricHookTypeId]: metricHookVariance,
@@ -39,6 +40,23 @@ export const make = <In, Out>(
   ...options
 })
 
+/** @internal */
+export const onModify = dual<
+  <In, Out>(f: (input: In) => void) => (self: MetricHook.MetricHook<In, Out>) => MetricHook.MetricHook<In, Out>,
+  <In, Out>(self: MetricHook.MetricHook<In, Out>, f: (input: In) => void) => MetricHook.MetricHook<In, Out>
+>(2, (self, f) => ({
+  [MetricHookTypeId]: metricHookVariance,
+  pipe() {
+    return pipeArguments(this, arguments)
+  },
+  get: self.get,
+  update: self.update,
+  modify: (input) => {
+    self.modify(input)
+    return f(input)
+  }
+}))
+
 /** @internal */
 export const onUpdate = dual<
   <In, Out>(f: (input: In) => void) => (self: MetricHook.MetricHook<In, Out>) => MetricHook.MetricHook<In, Out>,
@@ -52,7 +70,8 @@ export const onUpdate = dual<
   update: (input) => {
     self.update(input)
     return f(input)
-  }
+  },
+  modify: self.modify
 }))
 
 const bigint0 = BigInt(0)
@@ -67,13 +86,15 @@ export const counter = <A extends (number | bigint)>(
       ? (value: A) => value >= bigint0
       : (value: A) => value >= 0
     : (_value: A) => true
+  const update = (value: A) => {
+    if (canUpdate(value)) {
+      sum = (sum as any) + value
+    }
+  }
   return make({
     get: () => metricState.counter(sum as number) as unknown as MetricState.MetricState.Counter<A>,
-    update: (value) => {
-      if (canUpdate(value)) {
-        sum = (sum as any) + value
-      }
-    }
+    update,
+    modify: update
   })
 }
 
@@ -89,7 +110,8 @@ export const frequency = (key: MetricKey.MetricKey.Frequency): MetricHook.Metric
   }
   return make({
     get: () => metricState.frequency(values),
-    update
+    update,
+    modify: update
   })
 }
 
@@ -106,6 +128,9 @@ export const gauge: {
     get: () => metricState.gauge(value as number) as unknown as MetricState.MetricState.Gauge<A>,
     update: (v) => {
       value = v
+    },
+    modify: (v) => {
+      value = (value as any) + v
     }
   })
 }
@@ -182,7 +207,8 @@ export const histogram = (key: MetricKey.MetricKey.Histogram): MetricHook.Metric
         max,
         sum
       }),
-    update
+    update,
+    modify: update
   })
 }
 
@@ -258,7 +284,8 @@ export const summary = (key: MetricKey.MetricKey.Summary): MetricHook.MetricHook
         max,
         sum
       }),
-    update: ([value, timestamp]) => observe(value, timestamp)
+    update: ([value, timestamp]) => observe(value, timestamp),
+    modify: ([value, timestamp]) => observe(value, timestamp)
   })
 }
 

package/src/internal/metric/keyType.ts

@@ -117,10 +117,7 @@ class GaugeKeyType<A extends (number | bigint)> implements MetricKeyType.MetricK
   }
 }
 
-/**
- * @category model
- * @since 2.0.0
- */
+/** @internal */
 export class HistogramKeyType implements MetricKeyType.MetricKeyType.Histogram {
   readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
   readonly [HistogramKeyTypeTypeId]: MetricKeyType.HistogramKeyTypeTypeId = HistogramKeyTypeTypeId
@@ -176,10 +173,7 @@ class SummaryKeyType implements MetricKeyType.MetricKeyType.Summary {
   }
 }
 
-/**
- * @since 2.0.0
- * @category constructors
- */
+/** @internal */
 export const counter: <A extends number | bigint>(options?: {
   readonly bigint: boolean
   readonly incremental: boolean
@@ -189,18 +183,12 @@ export const counter: <A extends number | bigint>(options?: {
     options?.bigint ?? false
   )
 
-/**
- * @since 2.0.0
- * @category constructors
- */
+/** @internal */
 export const frequency = (options?: {
   readonly preregisteredWords?: ReadonlyArray<string> | undefined
 }): MetricKeyType.MetricKeyType.Frequency => new FrequencyKeyType(options?.preregisteredWords ?? [])
 
-/**
- * @since 2.0.0
- * @category constructors
- */
+/** @internal */
 export const gauge: <A extends number | bigint>(options?: {
   readonly bigint: boolean
 }) => GaugeKeyType<A> = (options) =>
@@ -208,18 +196,12 @@ export const gauge: <A extends number | bigint>(options?: {
     options?.bigint ?? false
   )
 
-/**
- * @since 2.0.0
- * @category constructors
- */
+/** @internal */
 export const histogram = (boundaries: MetricBoundaries.MetricBoundaries): MetricKeyType.MetricKeyType.Histogram => {
   return new HistogramKeyType(boundaries)
 }
 
-/**
- * @since 2.0.0
- * @category constructors
- */
+/** @internal */
 export const summary = (
   options: {
     readonly maxAge: Duration.DurationInput
@@ -231,44 +213,26 @@ export const summary = (
   return new SummaryKeyType(Duration.decode(options.maxAge), options.maxSize, options.error, options.quantiles)
 }
 
-/**
- * @since 2.0.0
- * @category refinements
- */
+/** @internal */
 export const isMetricKeyType = (u: unknown): u is MetricKeyType.MetricKeyType<unknown, unknown> =>
   hasProperty(u, MetricKeyTypeTypeId)
 
-/**
- * @since 2.0.0
- * @category refinements
- */
+/** @internal */
 export const isCounterKey = (u: unknown): u is MetricKeyType.MetricKeyType.Counter<number | bigint> =>
   hasProperty(u, CounterKeyTypeTypeId)
 
-/**
- * @since 2.0.0
- * @category refinements
- */
+/** @internal */
 export const isFrequencyKey = (u: unknown): u is MetricKeyType.MetricKeyType.Frequency =>
   hasProperty(u, FrequencyKeyTypeTypeId)
 
-/**
- * @since 2.0.0
- * @category refinements
- */
+/** @internal */
 export const isGaugeKey = (u: unknown): u is MetricKeyType.MetricKeyType.Gauge<number | bigint> =>
   hasProperty(u, GaugeKeyTypeTypeId)
 
-/**
- * @since 2.0.0
- * @category refinements
- */
+/** @internal */
 export const isHistogramKey = (u: unknown): u is MetricKeyType.MetricKeyType.Histogram =>
   hasProperty(u, HistogramKeyTypeTypeId)
 
-/**
- * @since 2.0.0
- * @category refinements
- */
+/** @internal */
 export const isSummaryKey = (u: unknown): u is MetricKeyType.MetricKeyType.Summary =>
   hasProperty(u, SummaryKeyTypeTypeId)

package/src/internal/metric/polling.ts

@@ -56,7 +56,14 @@ export const collectAll = <R, E, Out>(
       (extraTags) =>
         Array.from(
           metrics.map((pollingMetric) => pollingMetric.metric.unsafeValue(extraTags))
-        )
+        ),
+      (inputs: Array<any>, extraTags) => {
+        for (let i = 0; i < inputs.length; i++) {
+          const pollingMetric = metrics[i]!
+          const input = pipe(inputs, (x) => x[i])
+          pollingMetric.metric.unsafeModify(input, extraTags)
+        }
+      }
     ),
     poll: core.forEachSequential(metrics, (metric) => metric.poll)
   }

package/src/internal/metric.ts

@@ -20,6 +20,7 @@ import * as _effect from "./core-effect.js"
 import * as core from "./core.js"
 import * as metricBoundaries from "./metric/boundaries.js"
 import * as metricKey from "./metric/key.js"
+import * as metricKeyType from "./metric/keyType.js"
 import * as metricLabel from "./metric/label.js"
 import * as metricRegistry from "./metric/registry.js"
 
@@ -50,7 +51,8 @@ export const globalMetricRegistry: MetricRegistry.MetricRegistry = globalValue(
 export const make: Metric.MetricApply = function<Type, In, Out>(
   keyType: Type,
   unsafeUpdate: (input: In, extraTags: ReadonlyArray<MetricLabel.MetricLabel>) => void,
-  unsafeValue: (extraTags: ReadonlyArray<MetricLabel.MetricLabel>) => Out
+  unsafeValue: (extraTags: ReadonlyArray<MetricLabel.MetricLabel>) => Out,
+  unsafeModify: (input: In, extraTags: ReadonlyArray<MetricLabel.MetricLabel>) => void
 ): Metric.Metric<Type, In, Out> {
   const metric: Metric.Metric<Type, In, Out> = Object.assign(
     <A extends In, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
@@ -60,6 +62,7 @@ export const make: Metric.MetricApply = function<Type, In, Out>(
       keyType,
       unsafeUpdate,
       unsafeValue,
+      unsafeModify,
       register() {
         this.unsafeValue([])
         return this as any
@@ -80,7 +83,8 @@ export const mapInput = dual<
   make(
     self.keyType,
     (input, extraTags) => self.unsafeUpdate(f(input), extraTags),
-    self.unsafeValue
+    self.unsafeValue,
+    (input, extraTags) => self.unsafeModify(f(input), extraTags)
   ))
 
 /** @internal */
@@ -149,7 +153,8 @@ export const fromMetricKey = <Type extends MetricKeyType.MetricKeyType<any, any>
   return make(
     key.keyType,
     (input, extraTags) => hook(extraTags).update(input),
-    (extraTags) => hook(extraTags).get()
+    (extraTags) => hook(extraTags).get(),
+    (input, extraTags) => hook(extraTags).modify(input)
   )
 }
 
@@ -171,20 +176,30 @@ export const histogram = (name: string, boundaries: MetricBoundaries.MetricBound
 
 /* @internal */
 export const increment = (
-  self: Metric.Metric.Counter<number> | Metric.Metric.Counter<bigint>
-): Effect.Effect<void> => update(self as Metric.Metric.Counter<number>, self.keyType.bigint ? BigInt(1) as any : 1)
+  self:
+    | Metric.Metric.Counter<number>
+    | Metric.Metric.Counter<bigint>
+    | Metric.Metric.Gauge<number>
+    | Metric.Metric.Gauge<bigint>
+): Effect.Effect<void> =>
+  metricKeyType.isCounterKey(self.keyType)
+    ? update(self as Metric.Metric.Counter<number>, self.keyType.bigint ? BigInt(1) as any : 1)
+    : modify(self as Metric.Metric.Gauge<number>, self.keyType.bigint ? BigInt(1) as any : 1)
 
 /* @internal */
 export const incrementBy = dual<
   {
-    (amount: number): (self: Metric.Metric.Counter<number>) => Effect.Effect<void>
-    (amount: bigint): (self: Metric.Metric.Counter<bigint>) => Effect.Effect<void>
+    (amount: number): (self: Metric.Metric.Counter<number> | Metric.Metric.Counter<number>) => Effect.Effect<void>
+    (amount: bigint): (self: Metric.Metric.Counter<bigint> | Metric.Metric.Gauge<bigint>) => Effect.Effect<void>
   },
   {
-    (self: Metric.Metric.Counter<number>, amount: number): Effect.Effect<void>
-    (self: Metric.Metric.Counter<bigint>, amount: bigint): Effect.Effect<void>
+    (self: Metric.Metric.Counter<number> | Metric.Metric.Gauge<number>, amount: number): Effect.Effect<void>
+    (self: Metric.Metric.Counter<bigint> | Metric.Metric.Gauge<bigint>, amount: bigint): Effect.Effect<void>
   }
->(2, (self, amount) => update(self as any, amount))
+>(2, (self, amount) =>
+  metricKeyType.isCounterKey(self.keyType)
+    ? update(self as any, amount)
+    : modify(self as any, amount))
 
 /** @internal */
 export const map = dual<
@@ -194,7 +209,8 @@ export const map = dual<
   make(
     self.keyType,
     self.unsafeUpdate,
-    (extraTags) => f(self.unsafeValue(extraTags))
+    (extraTags) => f(self.unsafeValue(extraTags)),
+    self.unsafeModify
   ))
 
 /** @internal */
@@ -208,7 +224,23 @@ export const mapType = dual<
     self: Metric.Metric<Type, In, Out>,
     f: (type: Type) => Type2
   ) => Metric.Metric<Type2, In, Out>
->(2, (self, f) => make(f(self.keyType), self.unsafeUpdate, self.unsafeValue))
+>(2, (self, f) =>
+  make(
+    f(self.keyType),
+    self.unsafeUpdate,
+    self.unsafeValue,
+    self.unsafeModify
+  ))
+
+/** @internal */
+export const modify = dual<
+  <In>(input: In) => <Type, Out>(self: Metric.Metric<Type, In, Out>) => Effect.Effect<void>,
+  <Type, In, Out>(self: Metric.Metric<Type, In, Out>, input: In) => Effect.Effect<void>
+>(2, (self, input) =>
+  core.fiberRefGetWith(
+    core.currentMetricLabels,
+    (tags) => core.sync(() => self.unsafeModify(input, tags))
+  ))
 
 /* @internal */
 export const set = dual<
@@ -223,11 +255,12 @@ export const set = dual<
 >(2, (self, value) => update(self as any, value))
 
 /** @internal */
-export const succeed = <Out>(out: Out): Metric.Metric<void, unknown, Out> => make(void 0 as void, constVoid, () => out)
+export const succeed = <Out>(out: Out): Metric.Metric<void, unknown, Out> =>
+  make(void 0 as void, constVoid, () => out, constVoid)
 
 /** @internal */
 export const sync = <Out>(evaluate: LazyArg<Out>): Metric.Metric<void, unknown, Out> =>
-  make(void 0 as void, constVoid, evaluate)
+  make(void 0 as void, constVoid, evaluate, constVoid)
 
 /** @internal */
 export const summary = (
@@ -277,7 +310,12 @@ export const taggedWithLabelsInput = dual<
           input,
           Arr.union(f(input), extraTags)
         ),
-      self.unsafeValue
+      self.unsafeValue,
+      (input, extraTags) =>
+        self.unsafeModify(
+          input,
+          Arr.union(f(input), extraTags)
+        )
     ),
     constVoid
   ))
@@ -295,7 +333,8 @@ export const taggedWithLabels = dual<
   return make(
     self.keyType,
     (input, extraTags1) => self.unsafeUpdate(input, Arr.union(extraTags, extraTags1)),
-    (extraTags1) => self.unsafeValue(Arr.union(extraTags, extraTags1))
+    (extraTags1) => self.unsafeValue(Arr.union(extraTags, extraTags1)),
+    (input, extraTags1) => self.unsafeModify(input, Arr.union(extraTags, extraTags1))
   )
 })
 
@@ -520,7 +559,12 @@ export const zip = dual<
         self.unsafeUpdate(l, extraTags)
         that.unsafeUpdate(r, extraTags)
       },
-      (extraTags) => [self.unsafeValue(extraTags), that.unsafeValue(extraTags)]
+      (extraTags) => [self.unsafeValue(extraTags), that.unsafeValue(extraTags)],
+      (input: readonly [In, In2], extraTags) => {
+        const [l, r] = input
+        self.unsafeModify(l, extraTags)
+        that.unsafeModify(r, extraTags)
+      }
     )
 )
 

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.6.4"
+let moduleVersion = "3.6.5"
 
 export const getCurrentVersion = () => moduleVersion