envio 3.0.0-alpha.21 → 3.0.0-alpha.23

package/src/Prometheus.res

@@ -22,7 +22,7 @@ module Labels = {
       switch nonStringFields {
       | [] => items->Belt.Array.map(item => item.location)->Ok
       | nonStringItems =>
-        let nonStringItems = nonStringItems->Js.Array2.joinWith(", ")
+        let nonStringItems = nonStringItems->Array.joinUnsafe(", ")
         Error(
           `Label schema must be an object with string (or optional string) values. Non string values: ${nonStringItems}`,
         )
@@ -55,7 +55,7 @@ module MakeSafePromMetric = (
     switch labelSchema->Labels.getLabelNames {
     | Ok(labelNames) =>
       if metricNames->Utils.Set.has(name) {
-        Js.Exn.raiseError("Duplicate prometheus metric name: " ++ name)
+        JsError.throwWithMessage("Duplicate prometheus metric name: " ++ name)
       } else {
         metricNames->Utils.Set.add(name)->ignore
         let metric = M.make({
@@ -67,7 +67,7 @@ module MakeSafePromMetric = (
         {metric, labelSchema}
       }
 
-    | Error(error) => Js.Exn.raiseError(error)
+    | Error(error) => JsError.throwWithMessage(error)
     }
 
   let handleFloat = ({metric, labelSchema}: t<'a>, ~labels: 'a, ~value) =>
@@ -117,7 +117,6 @@ module SafeGauge = MakeSafePromMetric({
   let handleFloat = PromClient.Gauge.setFloat
 })
 
-
 module ProcessingBatch = {
   let loadTimeCounter = PromClient.Counter.makeCounter({
     "name": "envio_preload_seconds",
@@ -129,21 +128,9 @@ module ProcessingBatch = {
     "help": "Cumulative time spent executing event handlers during batch processing.",
   })
 
-  let writeTimeCounter = PromClient.Counter.makeCounter({
-    "name": "envio_storage_write_seconds",
-    "help": "Cumulative time spent writing batch data to storage.",
-  })
-
-  let writeCount = PromClient.Counter.makeCounter({
-    "name": "envio_storage_write_total",
-    "help": "Total number of batch writes to storage.",
-  })
-
-  let registerMetrics = (~loadDuration, ~handlerDuration, ~dbWriteDuration) => {
+  let registerMetrics = (~loadDuration, ~handlerDuration) => {
     loadTimeCounter->PromClient.Counter.incMany(loadDuration->(Utils.magic: float => int))
     handlerTimeCounter->PromClient.Counter.incMany(handlerDuration->(Utils.magic: float => int))
-    writeTimeCounter->PromClient.Counter.incMany(dbWriteDuration->(Utils.magic: float => int))
-    writeCount->PromClient.Counter.inc
   }
 }
 
@@ -227,7 +214,7 @@ module PreloadHandler = {
     mutable pendingCount: int,
     timerRef: Hrtime.timeRef,
   }
-  let operations: Js.Dict.t<operationRef> = Js.Dict.empty()
+  let operations: dict<operationRef> = Dict.make()
 
   let makeKey = (~contract, ~event) => contract ++ ":" ++ event
 
@@ -236,7 +223,7 @@ module PreloadHandler = {
     switch operations->Utils.Dict.dangerouslyGetNonOption(key) {
     | Some(operationRef) => operationRef.pendingCount = operationRef.pendingCount + 1
     | None =>
-      operations->Js.Dict.set(
+      operations->Dict.set(
         key,
         {
           pendingCount: 1,
@@ -250,7 +237,7 @@ module PreloadHandler = {
   let endOperation = (timerRef, ~contract, ~event) => {
     let key = makeKey(~contract, ~event)
     let labels = {"contract": contract, "event": event}
-    let operationRef = operations->Js.Dict.unsafeGet(key)
+    let operationRef = operations->Dict.getUnsafe(key)
     operationRef.pendingCount = operationRef.pendingCount - 1
     if operationRef.pendingCount === 0 {
       timeCounter->SafeCounter.handleFloat(
@@ -348,7 +335,7 @@ module ProcessStartTimeSeconds = {
   })
 
   let set = () => {
-    gauge->PromClient.Gauge.setFloat(Js.Date.now() /. 1000.0)
+    gauge->PromClient.Gauge.setFloat(Date.now() /. 1000.0)
   }
 }
 
@@ -593,9 +580,7 @@ module RollbackSuccess = {
   let increment = (~timeSeconds: float, ~rollbackedProcessedEvents: float) => {
     timeCounter->PromClient.Counter.incMany(timeSeconds->(Utils.magic: float => int))
     counter->PromClient.Counter.inc
-    eventsCounter->PromClient.Counter.incMany(
-      rollbackedProcessedEvents->Utils.floatToInt,
-    )
+    eventsCounter->PromClient.Counter.incMany(rollbackedProcessedEvents->Utils.floatToInt)
   }
 }
 
@@ -663,10 +648,7 @@ module ProgressEventsCount = {
   )
 
   let set = (~processedCount: float, ~chainId) => {
-    gauge->SafeGauge.handleFloat(
-      ~labels=chainId,
-      ~value=processedCount,
-    )
+    gauge->SafeGauge.handleFloat(~labels=chainId, ~value=processedCount)
   }
 }
 
@@ -755,50 +737,58 @@ module EffectQueueCount = {
 }
 
 module StorageLoad = {
-  let operationLabelsSchema = S.object(s => s.field("operation", S.string))
+  let loadLabelsSchema = S.schema(s =>
+    {
+      "operation": s.matches(S.string),
+      "storage": s.matches(S.string),
+    }
+  )
 
   let timeCounter = SafeCounter.makeOrThrow(
     ~name="envio_storage_load_seconds",
     ~help="Processing time taken to load data from storage.",
-    ~labelSchema=operationLabelsSchema,
+    ~labelSchema=loadLabelsSchema,
   )
 
   let sumTimeCounter = SafeCounter.makeOrThrow(
     ~name="envio_storage_load_seconds_total",
     ~help="Cumulative time spent loading data from storage during the indexing process.",
-    ~labelSchema=operationLabelsSchema,
+    ~labelSchema=loadLabelsSchema,
   )
 
   let counter = SafeCounter.makeOrThrow(
     ~name="envio_storage_load_total",
     ~help="Cumulative number of successful storage load operations during the indexing process.",
-    ~labelSchema=operationLabelsSchema,
+    ~labelSchema=loadLabelsSchema,
   )
 
   let whereSizeCounter = SafeCounter.makeOrThrow(
     ~name="envio_storage_load_where_size",
     ~help="Cumulative number of filter conditions ('where' items) used in storage load operations during the indexing process.",
-    ~labelSchema=operationLabelsSchema,
+    ~labelSchema=loadLabelsSchema,
   )
 
   let sizeCounter = SafeCounter.makeOrThrow(
     ~name="envio_storage_load_size",
     ~help="Cumulative number of records loaded from storage during the indexing process.",
-    ~labelSchema=operationLabelsSchema,
+    ~labelSchema=loadLabelsSchema,
   )
 
   type operationRef = {
     mutable pendingCount: int,
     timerRef: Hrtime.timeRef,
   }
-  let operations = Js.Dict.empty()
+  let operations = Dict.make()
+
+  let makeKey = (~storage, ~operation) => storage ++ ":" ++ operation
 
-  let startOperation = (~operation) => {
-    switch operations->Utils.Dict.dangerouslyGetNonOption(operation) {
+  let startOperation = (~storage, ~operation) => {
+    let key = makeKey(~storage, ~operation)
+    switch operations->Utils.Dict.dangerouslyGetNonOption(key) {
     | Some(operationRef) => operationRef.pendingCount = operationRef.pendingCount + 1
     | None =>
-      operations->Js.Dict.set(
-        operation,
+      operations->Dict.set(
+        key,
         (
           {
             pendingCount: 1,
@@ -810,43 +800,45 @@ module StorageLoad = {
     Hrtime.makeTimer()
   }
 
-  let endOperation = (timerRef, ~operation, ~whereSize, ~size) => {
-    let operationRef = operations->Js.Dict.unsafeGet(operation)
+  let endOperation = (timerRef, ~storage, ~operation, ~whereSize, ~size) => {
+    let key = makeKey(~storage, ~operation)
+    let labels = {"operation": operation, "storage": storage}
+    let operationRef = operations->Dict.getUnsafe(key)
     operationRef.pendingCount = operationRef.pendingCount - 1
     if operationRef.pendingCount === 0 {
       timeCounter->SafeCounter.handleFloat(
-        ~labels={operation},
+        ~labels,
         ~value=operationRef.timerRef->Hrtime.timeSince->Hrtime.toSecondsFloat,
       )
-      operations->Utils.Dict.deleteInPlace(operation)
+      operations->Utils.Dict.deleteInPlace(key)
     }
     sumTimeCounter->SafeCounter.handleFloat(
-      ~labels={operation},
+      ~labels,
       ~value=timerRef->Hrtime.timeSince->Hrtime.toSecondsFloat,
     )
-    counter->SafeCounter.increment(~labels={operation})
-    whereSizeCounter->SafeCounter.handleInt(~labels={operation}, ~value=whereSize)
-    sizeCounter->SafeCounter.handleInt(~labels={operation}, ~value=size)
+    counter->SafeCounter.increment(~labels)
+    whereSizeCounter->SafeCounter.handleInt(~labels, ~value=whereSize)
+    sizeCounter->SafeCounter.handleInt(~labels, ~value=size)
   }
 }
 
-module SinkWrite = {
-  let sinkLabelsSchema = S.object(s => s.field("sink", S.string))
+module StorageWrite = {
+  let storageLabelsSchema = S.object(s => s.field("storage", S.string))
 
   let timeCounter = SafeCounter.makeOrThrow(
-    ~name="envio_sink_write_seconds",
-    ~help="Processing time taken to write data to sink.",
-    ~labelSchema=sinkLabelsSchema,
+    ~name="envio_storage_write_seconds",
+    ~help="Cumulative time spent writing batch data to storage.",
+    ~labelSchema=storageLabelsSchema,
   )
 
   let counter = SafeCounter.makeOrThrow(
-    ~name="envio_sink_write_total",
-    ~help="Cumulative number of successful sink write operations during the indexing process.",
-    ~labelSchema=sinkLabelsSchema,
+    ~name="envio_storage_write_total",
+    ~help="Cumulative number of successful storage write operations during the indexing process.",
+    ~labelSchema=storageLabelsSchema,
   )
 
-  let increment = (~sinkName, ~timeSeconds) => {
-    timeCounter->SafeCounter.handleFloat(~labels={sinkName}, ~value=timeSeconds)
-    counter->SafeCounter.increment(~labels={sinkName})
+  let increment = (~storage, ~timeSeconds) => {
+    timeCounter->SafeCounter.handleFloat(~labels={storage}, ~value=timeSeconds)
+    counter->SafeCounter.increment(~labels={storage})
   }
 }