@effect/opentelemetry 0.60.0 → 4.0.0-beta.0

package/src/internal/metrics.ts

@@ -1,5 +1,4 @@
-import type { HrTime } from "@opentelemetry/api"
-import { ValueType } from "@opentelemetry/api"
+import { type HrTime, ValueType } from "@opentelemetry/api"
 import type * as Resources from "@opentelemetry/resources"
 import type {
   CollectionResult,
@@ -7,22 +6,14 @@ import type {
   Histogram,
   MetricCollectOptions,
   MetricData,
-  MetricProducer,
-  MetricReader
+  MetricProducer
 } from "@opentelemetry/sdk-metrics"
 import { AggregationTemporality, DataPointType, InstrumentType } from "@opentelemetry/sdk-metrics"
 import type { InstrumentDescriptor } from "@opentelemetry/sdk-metrics/build/src/InstrumentDescriptor.js"
 import * as Arr from "effect/Array"
-import type { DurationInput } from "effect/Duration"
-import * as Effect from "effect/Effect"
-import type { LazyArg } from "effect/Function"
-import * as Layer from "effect/Layer"
 import * as Metric from "effect/Metric"
-import type * as MetricKey from "effect/MetricKey"
-import * as MetricKeyType from "effect/MetricKeyType"
-import * as MetricState from "effect/MetricState"
-import * as Option from "effect/Option"
-import * as Resource from "../Resource.js"
+import type * as ServiceMap from "effect/ServiceMap"
+import type * as Metrics from "../Metrics.ts"
 
 const sdkName = "@effect/opentelemetry/Metrics"
 
@@ -30,11 +21,48 @@ type MetricDataWithInstrumentDescriptor = MetricData & {
   readonly descriptor: InstrumentDescriptor
 }
 
+interface PreviousHistogramState {
+  readonly count: number
+  readonly sum: number
+  readonly bucketCounts: ReadonlyArray<number>
+  readonly min: number
+  readonly max: number
+}
+
+interface PreviousSummaryState {
+  readonly count: number
+  readonly sum: number
+}
+
 /** @internal */
 export class MetricProducerImpl implements MetricProducer {
-  constructor(readonly resource: Resources.Resource) {}
+  resource: Resources.Resource
+  services: ServiceMap.ServiceMap<never>
+  temporality: Metrics.TemporalityPreference
+  startTimes: Map<string, HrTime>
+  startTimeNanos: HrTime
+  previousExportTimeNanos: HrTime
+  previousCounterState: Map<string, number | bigint>
+  previousHistogramState: Map<string, PreviousHistogramState>
+  previousFrequencyState: Map<string, Map<string, number>>
+  previousSummaryState: Map<string, PreviousSummaryState>
 
-  startTimes = new Map<string, HrTime>()
+  constructor(
+    resource: Resources.Resource,
+    services: ServiceMap.ServiceMap<never>,
+    temporality: Metrics.TemporalityPreference = "cumulative"
+  ) {
+    this.resource = resource
+    this.services = services
+    this.temporality = temporality
+    this.startTimes = new Map()
+    this.startTimeNanos = currentHrTime()
+    this.previousExportTimeNanos = this.startTimeNanos
+    this.previousCounterState = new Map()
+    this.previousHistogramState = new Map()
+    this.previousFrequencyState = new Map()
+    this.previousSummaryState = new Map()
+  }
 
   startTimeFor(name: string, hrTime: HrTime) {
     if (this.startTimes.has(name)) {
@@ -45,7 +73,7 @@ export class MetricProducerImpl implements MetricProducer {
   }
 
   collect(_options?: MetricCollectOptions): Promise<CollectionResult> {
-    const snapshot = Metric.unsafeSnapshot()
+    const snapshot = Metric.snapshotUnsafe(this.services)
     const hrTimeNow = currentHrTime()
     const metricData: Array<MetricData> = []
     const metricDataByName = new Map<string, MetricData>()
@@ -54,189 +82,320 @@ export class MetricProducerImpl implements MetricProducer {
       metricDataByName.set(data.descriptor.name, data)
     }
 
+    const isDelta = this.temporality === "delta"
+    const aggregationTemporality = isDelta
+      ? AggregationTemporality.DELTA
+      : AggregationTemporality.CUMULATIVE
+    const intervalStartTime = isDelta
+      ? this.previousExportTimeNanos
+      : this.startTimeNanos
+
     for (let i = 0, len = snapshot.length; i < len; i++) {
-      const { metricKey, metricState } = snapshot[i]
-      const attributes = Arr.reduce(metricKey.tags, {}, (acc: Record<string, string>, label) => {
-        acc[label.key] = label.value
-        return acc
-      })
-      const descriptor = descriptorFromKey(metricKey, attributes)
-      const startTime = this.startTimeFor(descriptor.name, hrTimeNow)
-
-      if (MetricState.isCounterState(metricState)) {
-        const dataPoint: DataPoint<number> = {
-          startTime,
-          endTime: hrTimeNow,
-          attributes,
-          value: Number(metricState.count)
-        }
-        if (metricDataByName.has(descriptor.name)) {
-          metricDataByName.get(descriptor.name)!.dataPoints.push(dataPoint as any)
-        } else {
-          addMetricData({
-            dataPointType: DataPointType.SUM,
-            descriptor,
-            isMonotonic: descriptor.type === InstrumentType.COUNTER,
-            aggregationTemporality: AggregationTemporality.CUMULATIVE,
-            dataPoints: [dataPoint]
-          })
-        }
-      } else if (MetricState.isGaugeState(metricState)) {
-        const dataPoint: DataPoint<number> = {
-          startTime,
-          endTime: hrTimeNow,
-          attributes,
-          value: Number(metricState.value)
-        }
-        if (metricDataByName.has(descriptor.name)) {
-          metricDataByName.get(descriptor.name)!.dataPoints.push(dataPoint as any)
-        } else {
-          addMetricData({
-            dataPointType: DataPointType.GAUGE,
-            descriptor,
-            aggregationTemporality: AggregationTemporality.CUMULATIVE,
-            dataPoints: [dataPoint]
-          })
-        }
-      } else if (MetricState.isHistogramState(metricState)) {
-        const size = metricState.buckets.length
-        const buckets = {
-          boundaries: Arr.allocate(size - 1) as Array<number>,
-          counts: Arr.allocate(size) as Array<number>
-        }
-        let i = 0
-        let prev = 0
-        for (const [boundary, value] of metricState.buckets) {
-          if (i < size - 1) {
-            buckets.boundaries[i] = boundary
+      const state = snapshot[i]
+      const attributes = state.attributes
+        ? Arr.reduce(Object.entries(state.attributes), {} as Record<string, string>, (acc, [key, value]) => {
+          acc[key] = String(value)
+          return acc
+        })
+        : {}
+      const metricKey = makeMetricKey(state.id, state.attributes)
+
+      switch (state.type) {
+        case "Counter": {
+          const currentCount = state.state.count
+          let reportValue: number | bigint = currentCount
+
+          if (isDelta) {
+            const previousCount = this.previousCounterState.get(metricKey)
+            if (previousCount !== undefined) {
+              if (typeof currentCount === "bigint" && typeof previousCount === "bigint") {
+                reportValue = currentCount - previousCount
+                // Handle reset: if current < previous, report current value
+                if (reportValue < 0n) {
+                  reportValue = currentCount
+                }
+              } else {
+                const curr = Number(currentCount)
+                const prev = Number(previousCount)
+                reportValue = curr - prev
+                // Handle reset
+                if (reportValue < 0) {
+                  reportValue = curr
+                }
+              }
+            }
+            this.previousCounterState.set(metricKey, currentCount)
+          }
+
+          const descriptor = descriptorFromState(state, attributes)
+          const startTime = this.startTimeFor(descriptor.name, intervalStartTime)
+          const dataPoint: DataPoint<number> = {
+            startTime,
+            endTime: hrTimeNow,
+            attributes,
+            value: Number(reportValue)
+          }
+          if (metricDataByName.has(state.id)) {
+            metricDataByName.get(state.id)!.dataPoints.push(dataPoint as any)
+          } else {
+            addMetricData({
+              dataPointType: DataPointType.SUM,
+              descriptor,
+              isMonotonic: state.state.incremental,
+              aggregationTemporality,
+              dataPoints: [dataPoint]
+            })
           }
-          buckets.counts[i] = value - prev
-          prev = value
-          i++
+          break
         }
-        const dataPoint: DataPoint<Histogram> = {
-          startTime,
-          endTime: hrTimeNow,
-          attributes,
-          value: {
-            buckets,
-            count: metricState.count,
-            min: metricState.min,
-            max: metricState.max,
-            sum: metricState.sum
+        case "Gauge": {
+          // Gauges don't have temporality - they always report current value
+          const descriptor = descriptorFromState(state, attributes)
+          const startTime = this.startTimeFor(descriptor.name, this.startTimeNanos)
+          const dataPoint: DataPoint<number> = {
+            startTime,
+            endTime: hrTimeNow,
+            attributes,
+            value: Number(state.state.value)
+          }
+          if (metricDataByName.has(state.id)) {
+            metricDataByName.get(state.id)!.dataPoints.push(dataPoint as any)
+          } else {
+            addMetricData({
+              dataPointType: DataPointType.GAUGE,
+              descriptor,
+              aggregationTemporality: AggregationTemporality.CUMULATIVE,
+              dataPoints: [dataPoint]
+            })
           }
+          break
         }
+        case "Histogram": {
+          const size = state.state.buckets.length
+          const currentBuckets = {
+            boundaries: Arr.allocate(size - 1) as Array<number>,
+            counts: Arr.allocate(size) as Array<number>
+          }
+          let idx = 0
+          let prev = 0
+          for (const [boundary, value] of state.state.buckets) {
+            if (idx < size - 1) {
+              currentBuckets.boundaries[idx] = boundary
+            }
+            currentBuckets.counts[idx] = value - prev
+            prev = value
+            idx++
+          }
 
-        if (metricDataByName.has(descriptor.name)) {
-          metricDataByName.get(descriptor.name)!.dataPoints.push(dataPoint as any)
-        } else {
-          addMetricData({
-            dataPointType: DataPointType.HISTOGRAM,
-            descriptor,
-            aggregationTemporality: AggregationTemporality.CUMULATIVE,
-            dataPoints: [dataPoint]
-          })
-        }
-      } else if (MetricState.isFrequencyState(metricState)) {
-        const dataPoints: Array<DataPoint<number>> = []
-        for (const [freqKey, value] of metricState.occurrences) {
-          dataPoints.push({
+          let reportCount = state.state.count
+          let reportSum = state.state.sum
+          let reportBucketCounts = currentBuckets.counts
+          const reportMin = state.state.min
+          const reportMax = state.state.max
+
+          if (isDelta) {
+            const previousState = this.previousHistogramState.get(metricKey)
+            if (previousState !== undefined) {
+              reportCount = state.state.count - previousState.count
+              reportSum = state.state.sum - previousState.sum
+              reportBucketCounts = currentBuckets.counts.map((c, i) =>
+                Math.max(0, c - (previousState.bucketCounts[i] ?? 0))
+              )
+            }
+            this.previousHistogramState.set(metricKey, {
+              count: state.state.count,
+              sum: state.state.sum,
+              bucketCounts: currentBuckets.counts.slice(),
+              min: state.state.min,
+              max: state.state.max
+            })
+          }
+
+          const descriptor = descriptorFromState(state, attributes)
+          const startTime = this.startTimeFor(descriptor.name, intervalStartTime)
+          const dataPoint: DataPoint<Histogram> = {
             startTime,
             endTime: hrTimeNow,
-            attributes: {
-              ...attributes,
-              key: freqKey
-            },
-            value
-          })
+            attributes,
+            value: {
+              buckets: {
+                boundaries: currentBuckets.boundaries,
+                counts: reportBucketCounts
+              },
+              count: reportCount,
+              min: reportMin,
+              max: reportMax,
+              sum: reportSum
+            }
+          }
+
+          if (metricDataByName.has(state.id)) {
+            metricDataByName.get(state.id)!.dataPoints.push(dataPoint as any)
+          } else {
+            addMetricData({
+              dataPointType: DataPointType.HISTOGRAM,
+              descriptor,
+              aggregationTemporality,
+              dataPoints: [dataPoint]
+            })
+          }
+          break
         }
-        if (metricDataByName.has(descriptor.name)) {
-          // eslint-disable-next-line no-restricted-syntax
-          metricDataByName.get(descriptor.name)!.dataPoints.push(...dataPoints as any)
-        } else {
-          addMetricData({
-            dataPointType: DataPointType.SUM,
-            descriptor: descriptorFromKey(metricKey, attributes),
-            aggregationTemporality: AggregationTemporality.CUMULATIVE,
-            isMonotonic: true,
-            dataPoints
-          })
+        case "Frequency": {
+          const dataPoints: Array<DataPoint<number>> = []
+          const currentOccurrences = new Map<string, number>()
+
+          for (const [freqKey, value] of state.state.occurrences) {
+            currentOccurrences.set(freqKey, value)
+            let reportValue = value
+
+            if (isDelta) {
+              const previousOccurrences = this.previousFrequencyState.get(metricKey)
+              if (previousOccurrences !== undefined) {
+                const previousValue = previousOccurrences.get(freqKey) ?? 0
+                reportValue = Math.max(0, value - previousValue)
+              }
+            }
+
+            const descriptor = descriptorFromState(state, attributes)
+            const startTime = this.startTimeFor(descriptor.name, intervalStartTime)
+            dataPoints.push({
+              startTime,
+              endTime: hrTimeNow,
+              attributes: {
+                ...attributes,
+                key: freqKey
+              },
+              value: reportValue
+            })
+          }
+
+          if (isDelta) {
+            this.previousFrequencyState.set(metricKey, currentOccurrences)
+          }
+
+          if (metricDataByName.has(state.id)) {
+            // oxlint-disable-next-line no-restricted-syntax
+            metricDataByName.get(state.id)!.dataPoints.push(...dataPoints as any)
+          } else {
+            const descriptor = descriptorFromState(state, attributes)
+            addMetricData({
+              dataPointType: DataPointType.SUM,
+              descriptor,
+              aggregationTemporality,
+              isMonotonic: true,
+              dataPoints
+            })
+          }
+          break
         }
-      } else if (MetricState.isSummaryState(metricState)) {
-        const dataPoints: Array<DataPoint<number>> = [{
-          startTime,
-          endTime: hrTimeNow,
-          attributes: { ...attributes, quantile: "min" },
-          value: metricState.min
-        }]
-        for (const [quantile, value] of metricState.quantiles) {
+        case "Summary": {
+          // Quantiles are always computed fresh from the sliding window
+          const dataPoints: Array<DataPoint<number>> = [{
+            startTime: intervalStartTime,
+            endTime: hrTimeNow,
+            attributes: { ...attributes, quantile: "min" },
+            value: state.state.min
+          }]
+          for (const [quantile, value] of state.state.quantiles) {
+            dataPoints.push({
+              startTime: intervalStartTime,
+              endTime: hrTimeNow,
+              attributes: { ...attributes, quantile: quantile.toString() },
+              value: value ?? 0
+            })
+          }
           dataPoints.push({
-            startTime,
+            startTime: intervalStartTime,
             endTime: hrTimeNow,
-            attributes: { ...attributes, quantile: quantile.toString() },
-            value: value._tag === "Some" ? value.value : 0
+            attributes: { ...attributes, quantile: "max" },
+            value: state.state.max
           })
-        }
-        dataPoints.push({
-          startTime,
-          endTime: hrTimeNow,
-          attributes: { ...attributes, quantile: "max" },
-          value: metricState.max
-        })
-        const countDataPoint: DataPoint<number> = {
-          startTime,
-          endTime: hrTimeNow,
-          attributes,
-          value: metricState.count
-        }
-        const sumDataPoint: DataPoint<number> = {
-          startTime,
-          endTime: hrTimeNow,
-          attributes,
-          value: metricState.sum
-        }
 
-        if (metricDataByName.has(`${descriptor.name}_quantiles`)) {
-          // eslint-disable-next-line no-restricted-syntax
-          metricDataByName.get(`${descriptor.name}_quantiles`)!.dataPoints.push(...dataPoints as any)
-          metricDataByName.get(`${descriptor.name}_count`)!.dataPoints.push(countDataPoint as any)
-          metricDataByName.get(`${descriptor.name}_sum`)!.dataPoints.push(sumDataPoint as any)
-        } else {
-          addMetricData({
-            dataPointType: DataPointType.SUM,
-            descriptor: descriptorFromKey(metricKey, attributes, "quantiles"),
-            aggregationTemporality: AggregationTemporality.CUMULATIVE,
-            isMonotonic: false,
-            dataPoints
-          })
-          addMetricData({
-            dataPointType: DataPointType.SUM,
-            descriptor: {
-              ...descriptorMeta(metricKey, "count"),
-              unit: "1",
-              type: InstrumentType.COUNTER,
-              valueType: ValueType.INT
-            },
-            aggregationTemporality: AggregationTemporality.CUMULATIVE,
-            isMonotonic: true,
-            dataPoints: [countDataPoint]
-          })
-          addMetricData({
-            dataPointType: DataPointType.SUM,
-            descriptor: {
-              ...descriptorMeta(metricKey, "sum"),
-              unit: "1",
-              type: InstrumentType.COUNTER,
-              valueType: ValueType.DOUBLE
-            },
-            aggregationTemporality: AggregationTemporality.CUMULATIVE,
-            isMonotonic: true,
-            dataPoints: [sumDataPoint]
-          })
+          let reportCount = state.state.count
+          let reportSum = state.state.sum
+
+          if (isDelta) {
+            const previousState = this.previousSummaryState.get(metricKey)
+            if (previousState !== undefined) {
+              reportCount = state.state.count - previousState.count
+              reportSum = state.state.sum - previousState.sum
+            }
+            this.previousSummaryState.set(metricKey, {
+              count: state.state.count,
+              sum: state.state.sum
+            })
+          }
+
+          const countDataPoint: DataPoint<number> = {
+            startTime: intervalStartTime,
+            endTime: hrTimeNow,
+            attributes,
+            value: reportCount
+          }
+          const sumDataPoint: DataPoint<number> = {
+            startTime: intervalStartTime,
+            endTime: hrTimeNow,
+            attributes,
+            value: reportSum
+          }
+
+          if (metricDataByName.has(`${state.id}_quantiles`)) {
+            // oxlint-disable-next-line no-restricted-syntax
+            metricDataByName.get(`${state.id}_quantiles`)!.dataPoints.push(...dataPoints as any)
+            metricDataByName.get(`${state.id}_count`)!.dataPoints.push(countDataPoint as any)
+            metricDataByName.get(`${state.id}_sum`)!.dataPoints.push(sumDataPoint as any)
+          } else {
+            const descriptor = descriptorFromState(state, attributes)
+            addMetricData({
+              dataPointType: DataPointType.SUM,
+              descriptor: {
+                ...descriptor,
+                name: `${descriptor.name}_quantiles`
+              },
+              aggregationTemporality,
+              isMonotonic: false,
+              dataPoints
+            })
+            addMetricData({
+              dataPointType: DataPointType.SUM,
+              descriptor: {
+                name: `${state.id}_count`,
+                description: state.description ?? "",
+                unit: "1",
+                type: InstrumentType.COUNTER,
+                valueType: ValueType.INT,
+                advice: {}
+              },
+              aggregationTemporality,
+              isMonotonic: true,
+              dataPoints: [countDataPoint]
+            })
+            addMetricData({
+              dataPointType: DataPointType.SUM,
+              descriptor: {
+                name: `${state.id}_sum`,
+                description: state.description ?? "",
+                unit: "1",
+                type: InstrumentType.COUNTER,
+                valueType: ValueType.DOUBLE,
+                advice: {}
+              },
+              aggregationTemporality,
+              isMonotonic: true,
+              dataPoints: [sumDataPoint]
+            })
+          }
+          break
         }
       }
     }
 
+    // Update the previous export time for delta calculations
+    if (isDelta) {
+      this.previousExportTimeNanos = hrTimeNow
+    }
+
     return Promise.resolve({
       resourceMetrics: {
         resource: this.resource,
@@ -250,38 +409,13 @@ export class MetricProducerImpl implements MetricProducer {
   }
 }
 
-const descriptorMeta = (
-  metricKey: MetricKey.MetricKey.Untyped,
-  suffix?: string
-) => ({
-  name: suffix ? `${metricKey.name}_${suffix}` : metricKey.name,
-  description: Option.getOrElse(metricKey.description, () => ""),
-  advice: {}
-})
-
-const descriptorFromKey = (
-  metricKey: MetricKey.MetricKey.Untyped,
-  tags: Record<string, string>,
-  suffix?: string
-): InstrumentDescriptor => ({
-  ...descriptorMeta(metricKey, suffix),
-  unit: tags.unit ?? tags.time_unit ?? "1",
-  type: instrumentTypeFromKey(metricKey),
-  valueType: "bigint" in metricKey.keyType && metricKey.keyType.bigint === true ? ValueType.INT : ValueType.DOUBLE
-})
-
-const instrumentTypeFromKey = (key: MetricKey.MetricKey.Untyped): InstrumentType => {
-  if (MetricKeyType.isHistogramKey(key.keyType)) {
-    return InstrumentType.HISTOGRAM
-  } else if (MetricKeyType.isGaugeKey(key.keyType)) {
-    return InstrumentType.OBSERVABLE_GAUGE
-  } else if (MetricKeyType.isFrequencyKey(key.keyType)) {
-    return InstrumentType.COUNTER
-  } else if (MetricKeyType.isCounterKey(key.keyType) && key.keyType.incremental) {
-    return InstrumentType.COUNTER
+/** Creates a unique key for a metric including its attributes */
+const makeMetricKey = (id: string, attributes: Metric.Metric.AttributeSet | undefined): string => {
+  if (attributes === undefined || Object.keys(attributes).length === 0) {
+    return id
   }
-
-  return InstrumentType.UP_DOWN_COUNTER
+  const sortedEntries = Object.entries(attributes).sort((a, b) => a[0].localeCompare(b[0]))
+  return `${id}:${JSON.stringify(sortedEntries)}`
 }
 
 const currentHrTime = (): HrTime => {
@@ -289,44 +423,41 @@ const currentHrTime = (): HrTime => {
   return [Math.floor(now / 1000), (now % 1000) * 1000000]
 }
 
-/** @internal */
-export const makeProducer = Effect.map(
-  Resource.Resource,
-  (resource): MetricProducer => new MetricProducerImpl(resource)
-)
+const descriptorFromState = (
+  state: Metric.Metric.Snapshot,
+  attributes: Record<string, string>
+): InstrumentDescriptor => {
+  const unit = attributes.unit ?? attributes.time_unit ?? "1"
+  return {
+    name: state.id,
+    description: state.description ?? "",
+    unit,
+    type: instrumentTypeFromSnapshot(state),
+    valueType: determineValueType(state),
+    advice: {}
+  }
+}
 
-/** @internal */
-export const registerProducer = (
-  self: MetricProducer,
-  metricReader: LazyArg<MetricReader | Arr.NonEmptyReadonlyArray<MetricReader>>,
-  options?: {
-    readonly shutdownTimeout?: DurationInput | undefined
+const instrumentTypeFromSnapshot = (state: Metric.Metric.Snapshot): InstrumentType => {
+  switch (state.type) {
+    case "Histogram":
+      return InstrumentType.HISTOGRAM
+    case "Gauge":
+      return InstrumentType.OBSERVABLE_GAUGE
+    case "Frequency":
+      return InstrumentType.COUNTER
+    case "Counter":
+      return state.state.incremental ? InstrumentType.COUNTER : InstrumentType.UP_DOWN_COUNTER
+    case "Summary":
+      return InstrumentType.COUNTER
   }
-) =>
-  Effect.acquireRelease(
-    Effect.sync(() => {
-      const reader = metricReader()
-      const readers: Array<MetricReader> = Array.isArray(reader) ? reader : [reader] as any
-      readers.forEach((reader) => reader.setMetricProducer(self))
-      return readers
-    }),
-    (readers) =>
-      Effect.promise(() =>
-        Promise.all(
-          readers.map((reader) => reader.shutdown())
-        )
-      ).pipe(
-        Effect.ignoreLogged,
-        Effect.interruptible,
-        Effect.timeoutOption(options?.shutdownTimeout ?? 3000)
-      )
-  )
+}
 
-/** @internal */
-export const layer = (evaluate: LazyArg<MetricReader | Arr.NonEmptyReadonlyArray<MetricReader>>, options?: {
-  readonly shutdownTimeout?: DurationInput | undefined
-}) =>
-  Layer.scopedDiscard(Effect.flatMap(
-    makeProducer,
-    (producer) => registerProducer(producer, evaluate, options)
-  ))
+const determineValueType = (state: Metric.Metric.Snapshot): ValueType => {
+  if (state.type === "Counter") {
+    return typeof state.state.count === "bigint" ? ValueType.INT : ValueType.DOUBLE
+  } else if (state.type === "Gauge") {
+    return typeof state.state.value === "bigint" ? ValueType.INT : ValueType.DOUBLE
+  }
+  return ValueType.DOUBLE
+}