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

package/src/internal/metric/key.ts

@@ -0,0 +1,167 @@
+import * as Arr from "../../Array.js"
+import type * as Duration from "../../Duration.js"
+import * as Equal from "../../Equal.js"
+import { dual, pipe } from "../../Function.js"
+import * as Hash from "../../Hash.js"
+import type * as MetricBoundaries from "../../MetricBoundaries.js"
+import type * as MetricKey from "../../MetricKey.js"
+import type * as MetricKeyType from "../../MetricKeyType.js"
+import type * as MetricLabel from "../../MetricLabel.js"
+import * as Option from "../../Option.js"
+import { pipeArguments } from "../../Pipeable.js"
+import { hasProperty } from "../../Predicate.js"
+import * as metricKeyType from "./keyType.js"
+import * as metricLabel from "./label.js"
+
+/** @internal */
+const MetricKeySymbolKey = "effect/MetricKey"
+
+/** @internal */
+export const MetricKeyTypeId: MetricKey.MetricKeyTypeId = Symbol.for(
+  MetricKeySymbolKey
+) as MetricKey.MetricKeyTypeId
+
+const metricKeyVariance = {
+  /* c8 ignore next */
+  _Type: (_: never) => _
+}
+
+const arrayEquivilence = Arr.getEquivalence(Equal.equals)
+
+/** @internal */
+class MetricKeyImpl<out Type extends MetricKeyType.MetricKeyType<any, any>> implements MetricKey.MetricKey<Type> {
+  readonly [MetricKeyTypeId] = metricKeyVariance
+  constructor(
+    readonly name: string,
+    readonly keyType: Type,
+    readonly description: Option.Option<string>,
+    readonly tags: ReadonlyArray<MetricLabel.MetricLabel> = []
+  ) {
+    this._hash = pipe(
+      Hash.string(this.name + this.description),
+      Hash.combine(Hash.hash(this.keyType)),
+      Hash.combine(Hash.array(this.tags))
+    )
+  }
+  readonly _hash: number;
+  [Hash.symbol](): number {
+    return this._hash
+  }
+  [Equal.symbol](u: unknown): boolean {
+    return isMetricKey(u) &&
+      this.name === u.name &&
+      Equal.equals(this.keyType, u.keyType) &&
+      Equal.equals(this.description, u.description) &&
+      arrayEquivilence(this.tags, u.tags)
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+export const isMetricKey = (u: unknown): u is MetricKey.MetricKey<MetricKeyType.MetricKeyType<unknown, unknown>> =>
+  hasProperty(u, MetricKeyTypeId)
+
+/** @internal */
+export const counter: {
+  (name: string, options?: {
+    readonly description?: string | undefined
+    readonly bigint?: false | undefined
+    readonly incremental?: boolean | undefined
+  }): MetricKey.MetricKey.Counter<number>
+  (name: string, options: {
+    readonly description?: string | undefined
+    readonly bigint: true
+    readonly incremental?: boolean | undefined
+  }): MetricKey.MetricKey.Counter<bigint>
+} = (name: string, options) =>
+  new MetricKeyImpl(
+    name,
+    metricKeyType.counter(options as any),
+    Option.fromNullable(options?.description)
+  )
+
+/** @internal */
+export const frequency = (name: string, options?: {
+  readonly description?: string | undefined
+  readonly preregisteredWords?: ReadonlyArray<string> | undefined
+}): MetricKey.MetricKey.Frequency =>
+  new MetricKeyImpl(name, metricKeyType.frequency(options), Option.fromNullable(options?.description))
+
+/** @internal */
+export const gauge: {
+  (name: string, options?: {
+    readonly description?: string | undefined
+    readonly bigint?: false | undefined
+  }): MetricKey.MetricKey.Gauge<number>
+  (name: string, options: {
+    readonly description?: string | undefined
+    readonly bigint: true
+  }): MetricKey.MetricKey.Gauge<bigint>
+} = (name, options) =>
+  new MetricKeyImpl(
+    name,
+    metricKeyType.gauge(options as any),
+    Option.fromNullable(options?.description)
+  )
+
+/** @internal */
+export const histogram = (
+  name: string,
+  boundaries: MetricBoundaries.MetricBoundaries,
+  description?: string
+): MetricKey.MetricKey.Histogram =>
+  new MetricKeyImpl(
+    name,
+    metricKeyType.histogram(boundaries),
+    Option.fromNullable(description)
+  )
+
+/** @internal */
+export const summary = (
+  options: {
+    readonly name: string
+    readonly maxAge: Duration.DurationInput
+    readonly maxSize: number
+    readonly error: number
+    readonly quantiles: ReadonlyArray<number>
+    readonly description?: string | undefined
+  }
+): MetricKey.MetricKey.Summary =>
+  new MetricKeyImpl(
+    options.name,
+    metricKeyType.summary(options),
+    Option.fromNullable(options.description)
+  )
+
+/** @internal */
+export const tagged = dual<
+  (
+    key: string,
+    value: string
+  ) => <Type extends MetricKeyType.MetricKeyType<any, any>>(
+    self: MetricKey.MetricKey<Type>
+  ) => MetricKey.MetricKey<Type>,
+  <Type extends MetricKeyType.MetricKeyType<any, any>>(
+    self: MetricKey.MetricKey<Type>,
+    key: string,
+    value: string
+  ) => MetricKey.MetricKey<Type>
+>(3, (self, key, value) => taggedWithLabels(self, [metricLabel.make(key, value)]))
+
+/** @internal */
+export const taggedWithLabels = dual<
+  (
+    extraTags: ReadonlyArray<MetricLabel.MetricLabel>
+  ) => <Type extends MetricKeyType.MetricKeyType<any, any>>(
+    self: MetricKey.MetricKey<Type>
+  ) => MetricKey.MetricKey<Type>,
+  <Type extends MetricKeyType.MetricKeyType<any, any>>(
+    self: MetricKey.MetricKey<Type>,
+    extraTags: ReadonlyArray<MetricLabel.MetricLabel>
+  ) => MetricKey.MetricKey<Type>
+>(2, (self, extraTags) =>
+  extraTags.length === 0
+    ? self
+    : new MetricKeyImpl(self.name, self.keyType, self.description, Arr.union(self.tags, extraTags)))

package/src/internal/metric/keyType.ts

@@ -0,0 +1,238 @@
+import * as Duration from "../../Duration.js"
+import * as Equal from "../../Equal.js"
+import { pipe } from "../../Function.js"
+import * as Hash from "../../Hash.js"
+import type * as MetricBoundaries from "../../MetricBoundaries.js"
+import type * as MetricKeyType from "../../MetricKeyType.js"
+import { pipeArguments } from "../../Pipeable.js"
+import { hasProperty } from "../../Predicate.js"
+
+/** @internal */
+const MetricKeyTypeSymbolKey = "effect/MetricKeyType"
+
+/** @internal */
+export const MetricKeyTypeTypeId: MetricKeyType.MetricKeyTypeTypeId = Symbol.for(
+  MetricKeyTypeSymbolKey
+) as MetricKeyType.MetricKeyTypeTypeId
+
+/** @internal */
+const CounterKeyTypeSymbolKey = "effect/MetricKeyType/Counter"
+
+/** @internal */
+export const CounterKeyTypeTypeId: MetricKeyType.CounterKeyTypeTypeId = Symbol.for(
+  CounterKeyTypeSymbolKey
+) as MetricKeyType.CounterKeyTypeTypeId
+
+/** @internal */
+const FrequencyKeyTypeSymbolKey = "effect/MetricKeyType/Frequency"
+
+/** @internal */
+export const FrequencyKeyTypeTypeId: MetricKeyType.FrequencyKeyTypeTypeId = Symbol.for(
+  FrequencyKeyTypeSymbolKey
+) as MetricKeyType.FrequencyKeyTypeTypeId
+
+/** @internal */
+const GaugeKeyTypeSymbolKey = "effect/MetricKeyType/Gauge"
+
+/** @internal */
+export const GaugeKeyTypeTypeId: MetricKeyType.GaugeKeyTypeTypeId = Symbol.for(
+  GaugeKeyTypeSymbolKey
+) as MetricKeyType.GaugeKeyTypeTypeId
+
+/** @internal */
+const HistogramKeyTypeSymbolKey = "effect/MetricKeyType/Histogram"
+
+/** @internal */
+export const HistogramKeyTypeTypeId: MetricKeyType.HistogramKeyTypeTypeId = Symbol.for(
+  HistogramKeyTypeSymbolKey
+) as MetricKeyType.HistogramKeyTypeTypeId
+
+/** @internal */
+const SummaryKeyTypeSymbolKey = "effect/MetricKeyType/Summary"
+
+/** @internal */
+export const SummaryKeyTypeTypeId: MetricKeyType.SummaryKeyTypeTypeId = Symbol.for(
+  SummaryKeyTypeSymbolKey
+) as MetricKeyType.SummaryKeyTypeTypeId
+
+const metricKeyTypeVariance = {
+  /* c8 ignore next */
+  _In: (_: unknown) => _,
+  /* c8 ignore next */
+  _Out: (_: never) => _
+}
+
+/** @internal */
+class CounterKeyType<A extends (number | bigint)> implements MetricKeyType.MetricKeyType.Counter<A> {
+  readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
+  readonly [CounterKeyTypeTypeId]: MetricKeyType.CounterKeyTypeTypeId = CounterKeyTypeTypeId
+  constructor(readonly incremental: boolean, readonly bigint: boolean) {
+    this._hash = Hash.string(CounterKeyTypeSymbolKey)
+  }
+  readonly _hash: number;
+  [Hash.symbol](): number {
+    return this._hash
+  }
+  [Equal.symbol](that: unknown): boolean {
+    return isCounterKey(that)
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+const FrequencyKeyTypeHash = Hash.string(FrequencyKeyTypeSymbolKey)
+
+/** @internal */
+class FrequencyKeyType implements MetricKeyType.MetricKeyType.Frequency {
+  readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
+  readonly [FrequencyKeyTypeTypeId]: MetricKeyType.FrequencyKeyTypeTypeId = FrequencyKeyTypeTypeId
+  constructor(readonly preregisteredWords: ReadonlyArray<string>) {}
+  [Hash.symbol](): number {
+    return FrequencyKeyTypeHash
+  }
+  [Equal.symbol](that: unknown): boolean {
+    return isFrequencyKey(that)
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+const GaugeKeyTypeHash = Hash.string(GaugeKeyTypeSymbolKey)
+
+/** @internal */
+class GaugeKeyType<A extends (number | bigint)> implements MetricKeyType.MetricKeyType.Gauge<A> {
+  readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
+  readonly [GaugeKeyTypeTypeId]: MetricKeyType.GaugeKeyTypeTypeId = GaugeKeyTypeTypeId
+  constructor(readonly bigint: boolean) {}
+  [Hash.symbol](): number {
+    return GaugeKeyTypeHash
+  }
+  [Equal.symbol](that: unknown): boolean {
+    return isGaugeKey(that)
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+export class HistogramKeyType implements MetricKeyType.MetricKeyType.Histogram {
+  readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
+  readonly [HistogramKeyTypeTypeId]: MetricKeyType.HistogramKeyTypeTypeId = HistogramKeyTypeTypeId
+  constructor(readonly boundaries: MetricBoundaries.MetricBoundaries) {
+    this._hash = pipe(
+      Hash.string(HistogramKeyTypeSymbolKey),
+      Hash.combine(Hash.hash(this.boundaries))
+    )
+  }
+  readonly _hash: number;
+  [Hash.symbol](): number {
+    return this._hash
+  }
+  [Equal.symbol](that: unknown): boolean {
+    return isHistogramKey(that) && Equal.equals(this.boundaries, that.boundaries)
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+class SummaryKeyType implements MetricKeyType.MetricKeyType.Summary {
+  readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
+  readonly [SummaryKeyTypeTypeId]: MetricKeyType.SummaryKeyTypeTypeId = SummaryKeyTypeTypeId
+  constructor(
+    readonly maxAge: Duration.Duration,
+    readonly maxSize: number,
+    readonly error: number,
+    readonly quantiles: ReadonlyArray<number>
+  ) {
+    this._hash = pipe(
+      Hash.string(SummaryKeyTypeSymbolKey),
+      Hash.combine(Hash.hash(this.maxAge)),
+      Hash.combine(Hash.hash(this.maxSize)),
+      Hash.combine(Hash.hash(this.error)),
+      Hash.combine(Hash.array(this.quantiles))
+    )
+  }
+  readonly _hash: number;
+  [Hash.symbol](): number {
+    return this._hash
+  }
+  [Equal.symbol](that: unknown): boolean {
+    return isSummaryKey(that) &&
+      Equal.equals(this.maxAge, that.maxAge) &&
+      this.maxSize === that.maxSize &&
+      this.error === that.error &&
+      Equal.equals(this.quantiles, that.quantiles)
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+export const counter: <A extends number | bigint>(options?: {
+  readonly bigint: boolean
+  readonly incremental: boolean
+}) => CounterKeyType<A> = (options) =>
+  new CounterKeyType(
+    options?.incremental ?? false,
+    options?.bigint ?? false
+  )
+
+/** @internal */
+export const frequency = (options?: {
+  readonly preregisteredWords?: ReadonlyArray<string> | undefined
+}): MetricKeyType.MetricKeyType.Frequency => new FrequencyKeyType(options?.preregisteredWords ?? [])
+
+/** @internal */
+export const gauge: <A extends number | bigint>(options?: {
+  readonly bigint: boolean
+}) => GaugeKeyType<A> = (options) =>
+  new GaugeKeyType(
+    options?.bigint ?? false
+  )
+
+/** @internal */
+export const histogram = (boundaries: MetricBoundaries.MetricBoundaries): MetricKeyType.MetricKeyType.Histogram => {
+  return new HistogramKeyType(boundaries)
+}
+
+/** @internal */
+export const summary = (
+  options: {
+    readonly maxAge: Duration.DurationInput
+    readonly maxSize: number
+    readonly error: number
+    readonly quantiles: ReadonlyArray<number>
+  }
+): MetricKeyType.MetricKeyType.Summary => {
+  return new SummaryKeyType(Duration.decode(options.maxAge), options.maxSize, options.error, options.quantiles)
+}
+
+/** @internal */
+export const isMetricKeyType = (u: unknown): u is MetricKeyType.MetricKeyType<unknown, unknown> =>
+  hasProperty(u, MetricKeyTypeTypeId)
+
+/** @internal */
+export const isCounterKey = (u: unknown): u is MetricKeyType.MetricKeyType.Counter<number | bigint> =>
+  hasProperty(u, CounterKeyTypeTypeId)
+
+/** @internal */
+export const isFrequencyKey = (u: unknown): u is MetricKeyType.MetricKeyType.Frequency =>
+  hasProperty(u, FrequencyKeyTypeTypeId)
+
+/** @internal */
+export const isGaugeKey = (u: unknown): u is MetricKeyType.MetricKeyType.Gauge<number | bigint> =>
+  hasProperty(u, GaugeKeyTypeTypeId)
+
+/** @internal */
+export const isHistogramKey = (u: unknown): u is MetricKeyType.MetricKeyType.Histogram =>
+  hasProperty(u, HistogramKeyTypeTypeId)
+
+/** @internal */
+export const isSummaryKey = (u: unknown): u is MetricKeyType.MetricKeyType.Summary =>
+  hasProperty(u, SummaryKeyTypeTypeId)

package/src/internal/metric/label.ts

@@ -0,0 +1,41 @@
+import * as Equal from "../../Equal.js"
+import * as Hash from "../../Hash.js"
+import type * as MetricLabel from "../../MetricLabel.js"
+import { pipeArguments } from "../../Pipeable.js"
+import { hasProperty } from "../../Predicate.js"
+
+/** @internal */
+const MetricLabelSymbolKey = "effect/MetricLabel"
+
+/** @internal */
+export const MetricLabelTypeId: MetricLabel.MetricLabelTypeId = Symbol.for(
+  MetricLabelSymbolKey
+) as MetricLabel.MetricLabelTypeId
+
+/** @internal */
+class MetricLabelImpl implements MetricLabel.MetricLabel {
+  readonly [MetricLabelTypeId]: MetricLabel.MetricLabelTypeId = MetricLabelTypeId
+  readonly _hash: number
+  constructor(readonly key: string, readonly value: string) {
+    this._hash = Hash.string(MetricLabelSymbolKey + this.key + this.value)
+  }
+  [Hash.symbol](): number {
+    return this._hash
+  }
+  [Equal.symbol](that: unknown): boolean {
+    return isMetricLabel(that) &&
+      this.key === that.key &&
+      this.value === that.value
+  }
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+export const make = (key: string, value: string): MetricLabel.MetricLabel => {
+  return new MetricLabelImpl(key, value)
+}
+
+/** @internal */
+export const isMetricLabel = (u: unknown): u is MetricLabel.MetricLabel => hasProperty(u, MetricLabelTypeId)

package/src/internal/metric/pair.ts

@@ -0,0 +1,48 @@
+import type * as MetricKey from "../../MetricKey.js"
+import type * as MetricKeyType from "../../MetricKeyType.js"
+import type * as MetricPair from "../../MetricPair.js"
+import type * as MetricState from "../../MetricState.js"
+import { pipeArguments } from "../../Pipeable.js"
+
+/** @internal */
+const MetricPairSymbolKey = "effect/MetricPair"
+
+/** @internal */
+export const MetricPairTypeId: MetricPair.MetricPairTypeId = Symbol.for(
+  MetricPairSymbolKey
+) as MetricPair.MetricPairTypeId
+
+const metricPairVariance = {
+  /* c8 ignore next */
+  _Type: (_: never) => _
+}
+
+/** @internal */
+export const make = <Type extends MetricKeyType.MetricKeyType<any, any>>(
+  metricKey: MetricKey.MetricKey<Type>,
+  metricState: MetricState.MetricState<MetricKeyType.MetricKeyType.OutType<Type>>
+): MetricPair.MetricPair.Untyped => {
+  return {
+    [MetricPairTypeId]: metricPairVariance,
+    metricKey,
+    metricState,
+    pipe() {
+      return pipeArguments(this, arguments)
+    }
+  }
+}
+
+/** @internal */
+export const unsafeMake = <Type extends MetricKeyType.MetricKeyType<any, any>>(
+  metricKey: MetricKey.MetricKey<Type>,
+  metricState: MetricState.MetricState.Untyped
+): MetricPair.MetricPair.Untyped => {
+  return {
+    [MetricPairTypeId]: metricPairVariance,
+    metricKey,
+    metricState,
+    pipe() {
+      return pipeArguments(this, arguments)
+    }
+  }
+}

package/src/internal/metric/polling.ts

@@ -0,0 +1,149 @@
+import type * as Effect from "../../Effect.js"
+import type * as Fiber from "../../Fiber.js"
+import { dual, pipe } from "../../Function.js"
+import type * as Metric from "../../Metric.js"
+import type * as MetricPolling from "../../MetricPolling.js"
+import { pipeArguments } from "../../Pipeable.js"
+import type * as Schedule from "../../Schedule.js"
+import type * as Scope from "../../Scope.js"
+import * as core from "../core.js"
+import * as metric from "../metric.js"
+import * as schedule_ from "../schedule.js"
+
+/** @internal */
+const MetricPollingSymbolKey = "effect/MetricPolling"
+
+/** @internal */
+export const MetricPollingTypeId: MetricPolling.MetricPollingTypeId = Symbol.for(
+  MetricPollingSymbolKey
+) as MetricPolling.MetricPollingTypeId
+
+/** @internal */
+export const make = <Type, In, Out, R, E>(
+  metric: Metric.Metric<Type, In, Out>,
+  poll: Effect.Effect<In, E, R>
+): MetricPolling.MetricPolling<Type, In, R, E, Out> => {
+  return {
+    [MetricPollingTypeId]: MetricPollingTypeId,
+    pipe() {
+      return pipeArguments(this, arguments)
+    },
+    metric,
+    poll
+  }
+}
+
+/** @internal */
+export const collectAll = <R, E, Out>(
+  iterable: Iterable<MetricPolling.MetricPolling<any, any, R, E, Out>>
+): MetricPolling.MetricPolling<Array<any>, Array<any>, R, E, Array<Out>> => {
+  const metrics = Array.from(iterable)
+  return {
+    [MetricPollingTypeId]: MetricPollingTypeId,
+    pipe() {
+      return pipeArguments(this, arguments)
+    },
+    metric: metric.make(
+      Array.of<any>(void 0) as Array<any>,
+      (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.unsafeUpdate(input, extraTags)
+        }
+      },
+      (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)
+  }
+}
+
+/** @internal */
+export const launch = dual<
+  <A2, R2>(
+    schedule: Schedule.Schedule<A2, unknown, R2>
+  ) => <Type, In, R, E, Out>(
+    self: MetricPolling.MetricPolling<Type, In, R, E, Out>
+  ) => Effect.Effect<Fiber.Fiber<A2, E>, never, R | R2 | Scope.Scope>,
+  <Type, In, R, E, Out, A2, R2>(
+    self: MetricPolling.MetricPolling<Type, In, R, E, Out>,
+    schedule: Schedule.Schedule<A2, unknown, R2>
+  ) => Effect.Effect<Fiber.Fiber<A2, E>, never, R | R2 | Scope.Scope>
+>(2, (self, schedule) =>
+  pipe(
+    pollAndUpdate(self),
+    core.zipRight(metric.value(self.metric)),
+    schedule_.scheduleForked(schedule)
+  ))
+
+/** @internal */
+export const poll = <Type, In, R, E, Out>(
+  self: MetricPolling.MetricPolling<Type, In, R, E, Out>
+): Effect.Effect<In, E, R> => self.poll
+
+/** @internal */
+export const pollAndUpdate = <Type, In, R, E, Out>(
+  self: MetricPolling.MetricPolling<Type, In, R, E, Out>
+): Effect.Effect<void, E, R> => core.flatMap(self.poll, (value) => metric.update(self.metric, value))
+
+/** @internal */
+export const retry = dual<
+  <X, E, R2>(
+    policy: Schedule.Schedule<X, E, R2>
+  ) => <Type, In, R, Out>(
+    self: MetricPolling.MetricPolling<Type, In, R, E, Out>
+  ) => MetricPolling.MetricPolling<Type, In, R | R2, E, Out>,
+  <Type, In, R, E, Out, X, R2>(
+    self: MetricPolling.MetricPolling<Type, In, R, E, Out>,
+    policy: Schedule.Schedule<X, E, R2>
+  ) => MetricPolling.MetricPolling<Type, In, R | R2, E, Out>
+>(2, (self, policy) => ({
+  [MetricPollingTypeId]: MetricPollingTypeId,
+  pipe() {
+    return pipeArguments(this, arguments)
+  },
+  metric: self.metric,
+  poll: schedule_.retry_Effect(self.poll, policy)
+}))
+
+/** @internal */
+export const zip = dual<
+  <Type2, In2, R2, E2, Out2>(
+    that: MetricPolling.MetricPolling<Type2, In2, R2, E2, Out2>
+  ) => <Type, In, R, E, Out>(
+    self: MetricPolling.MetricPolling<Type, In, R, E, Out>
+  ) => MetricPolling.MetricPolling<
+    readonly [Type, Type2],
+    readonly [In, In2],
+    R | R2,
+    E | E2,
+    [Out, Out2]
+  >,
+  <Type, In, R, E, Out, Type2, In2, R2, E2, Out2>(
+    self: MetricPolling.MetricPolling<Type, In, R, E, Out>,
+    that: MetricPolling.MetricPolling<Type2, In2, R2, E2, Out2>
+  ) => MetricPolling.MetricPolling<
+    readonly [Type, Type2],
+    readonly [In, In2],
+    R | R2,
+    E | E2,
+    [Out, Out2]
+  >
+>(2, (self, that) => ({
+  [MetricPollingTypeId]: MetricPollingTypeId,
+  pipe() {
+    return pipeArguments(this, arguments)
+  },
+  metric: pipe(self.metric, metric.zip(that.metric)),
+  poll: core.zip(self.poll, that.poll)
+}))