envio 3.0.0-alpha.2 → 3.0.0-alpha.3

package/src/Benchmark.res.mjs

@@ -0,0 +1,398 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Fs from "fs";
+import * as Env from "./Env.res.mjs";
+import * as Path from "path";
+import * as NodeJs from "./bindings/NodeJs.res.mjs";
+import * as DateFns from "./bindings/DateFns.res.mjs";
+import * as Js_dict from "rescript/lib/es6/js_dict.js";
+import * as Logging from "./Logging.res.mjs";
+import * as DateFns$1 from "date-fns";
+import * as Throttler from "./Throttler.res.mjs";
+import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
+import * as BigDecimal from "./bindings/BigDecimal.res.mjs";
+import * as Prometheus from "./Prometheus.res.mjs";
+import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
+import BignumberJs from "bignumber.js";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+
+var schema = S$RescriptSchema.schema(function (s) {
+      return {
+              counters: s.m(S$RescriptSchema.dict(S$RescriptSchema.$$float)),
+              startTime: s.m(S$RescriptSchema.datetime(S$RescriptSchema.string, undefined)),
+              endTime: s.m(S$RescriptSchema.datetime(S$RescriptSchema.string, undefined))
+            };
+    });
+
+function make() {
+  return {
+          counters: {},
+          startTime: new Date(),
+          endTime: new Date()
+        };
+}
+
+function increment(self, label, amount) {
+  self.endTime = new Date();
+  var current = self.counters[label];
+  if (current !== undefined) {
+    var newAmount = current + amount;
+    self.counters[label] = newAmount;
+    return newAmount;
+  }
+  self.counters[label] = amount;
+  return amount;
+}
+
+var MillisAccum = {
+  schema: schema,
+  make: make,
+  increment: increment
+};
+
+var schema$1 = S$RescriptSchema.schema(function (s) {
+      return {
+              count: s.m(S$RescriptSchema.$$float),
+              min: s.m(S$RescriptSchema.$$float),
+              max: s.m(S$RescriptSchema.$$float),
+              sum: s.m(BigDecimal.schema),
+              sumOfSquares: s.m(S$RescriptSchema.option(BigDecimal.schema)),
+              decimalPlaces: s.m(S$RescriptSchema.$$int)
+            };
+    });
+
+function make$1(val, decimalPlacesOpt) {
+  var decimalPlaces = decimalPlacesOpt !== undefined ? decimalPlacesOpt : 2;
+  var bigDecimal = new BignumberJs(val);
+  return {
+          count: 1,
+          min: val,
+          max: val,
+          sum: bigDecimal,
+          sumOfSquares: Env.Benchmark.shouldSaveStdDev ? bigDecimal.multipliedBy(bigDecimal) : undefined,
+          decimalPlaces: decimalPlaces
+        };
+}
+
+function add(self, val) {
+  var bigDecimal = new BignumberJs(val);
+  return {
+          count: self.count + 1,
+          min: self.min < val ? self.min : val,
+          max: self.max > val ? self.max : val,
+          sum: self.sum.plus(bigDecimal),
+          sumOfSquares: Belt_Option.map(self.sumOfSquares, (function (s) {
+                  return s.plus(bigDecimal.multipliedBy(bigDecimal));
+                })),
+          decimalPlaces: self.decimalPlaces
+        };
+}
+
+var DataSet = {
+  schema: schema$1,
+  make: make$1,
+  add: add
+};
+
+var schema$2 = S$RescriptSchema.dict(schema$1);
+
+function make$2() {
+  return {};
+}
+
+function add$1(self, label, value, decimalPlacesOpt) {
+  var decimalPlaces = decimalPlacesOpt !== undefined ? decimalPlacesOpt : 2;
+  var dataSet = self[label];
+  if (dataSet !== undefined) {
+    var updated = add(dataSet, value);
+    self[label] = updated;
+    return updated;
+  }
+  var $$new = make$1(value, decimalPlaces);
+  self[label] = $$new;
+  return $$new;
+}
+
+var Group = {
+  schema: schema$2,
+  make: make$2,
+  add: add$1
+};
+
+var schema$3 = S$RescriptSchema.dict(schema$2);
+
+function make$3() {
+  return {};
+}
+
+function add$2(self, group, label, value, decimalPlacesOpt) {
+  var decimalPlaces = decimalPlacesOpt !== undefined ? decimalPlacesOpt : 2;
+  var group$1 = self[group];
+  var group$2;
+  if (group$1 !== undefined) {
+    group$2 = group$1;
+  } else {
+    var newGroup = {};
+    self[group] = newGroup;
+    group$2 = newGroup;
+  }
+  return add$1(group$2, label, value, decimalPlaces);
+}
+
+var SummaryData = {
+  DataSet: DataSet,
+  Group: Group,
+  schema: schema$3,
+  make: make$3,
+  add: add$2
+};
+
+function round($$float, precisionOpt) {
+  var precision = precisionOpt !== undefined ? precisionOpt : 2;
+  var factor = Math.pow(10.0, precision);
+  return Math.round($$float * factor) / factor;
+}
+
+function makeFromDataSet(dataSet) {
+  var n = dataSet.count;
+  var countBigDecimal = new BignumberJs(n);
+  var mean = dataSet.sum.dividedBy(countBigDecimal);
+  var roundBigDecimal = function (bd) {
+    return bd.decimalPlaces(dataSet.decimalPlaces).toNumber();
+  };
+  var roundFloat = function ($$float) {
+    return round($$float, dataSet.decimalPlaces);
+  };
+  var stdDev = Belt_Option.map(dataSet.sumOfSquares, (function (sumOfSquares) {
+          var variance = sumOfSquares.dividedBy(countBigDecimal).minus(mean.multipliedBy(mean));
+          return roundBigDecimal(variance.sqrt());
+        }));
+  return {
+          n: n,
+          mean: roundBigDecimal(mean),
+          "std-dev": stdDev,
+          min: roundFloat(dataSet.min),
+          max: roundFloat(dataSet.max),
+          sum: roundBigDecimal(dataSet.sum)
+        };
+}
+
+var Stats = {
+  round: round,
+  makeFromDataSet: makeFromDataSet
+};
+
+var schema$4 = S$RescriptSchema.schema(function (s) {
+      return {
+              millisAccum: s.m(schema),
+              summaryData: s.m(schema$3)
+            };
+    });
+
+function make$4() {
+  return {
+          millisAccum: make(),
+          summaryData: {}
+        };
+}
+
+var addDataSet = Env.Benchmark.SaveDataStrategy.shouldSavePrometheus(Env.Benchmark.saveDataStrategy) ? (function (dataSet, group, label) {
+      var match = makeFromDataSet(dataSet);
+      Prometheus.BenchmarkSummaryData.set(group, label, match.n, match.mean, match["std-dev"], match.min, match.max, match.sum);
+    }) : (function (_dataSet, param, param$1) {
+      
+    });
+
+var setCounterMillis = Env.Benchmark.SaveDataStrategy.shouldSavePrometheus(Env.Benchmark.saveDataStrategy) ? (function (millisAccum, label, millis) {
+      var totalRuntimeMillis = millisAccum.endTime.getTime() - millisAccum.startTime.getTime();
+      Prometheus.BenchmarkCounters.set(label, millis, totalRuntimeMillis);
+    }) : (function (param, param$1, param$2) {
+      
+    });
+
+var LiveMetrics = {
+  addDataSet: addDataSet,
+  setCounterMillis: setCounterMillis
+};
+
+function incrementMillis(self, label, amount) {
+  var nextMillis = increment(self.millisAccum, label, amount);
+  setCounterMillis(self.millisAccum, label, nextMillis);
+}
+
+function addSummaryData(self, group, label, value, decimalPlacesOpt) {
+  var decimalPlaces = decimalPlacesOpt !== undefined ? decimalPlacesOpt : 2;
+  var updatedDataSet = add$2(self.summaryData, group, label, value, decimalPlaces);
+  addDataSet(updatedDataSet, group, label);
+}
+
+var Data = {
+  schema: schema$4,
+  make: make$4,
+  LiveMetrics: LiveMetrics,
+  incrementMillis: incrementMillis,
+  addSummaryData: addSummaryData
+};
+
+var data = make$4();
+
+var throttler = Throttler.make(Env.ThrottleWrites.jsonFileBenchmarkIntervalMillis, Logging.createChild({
+          context: "Benchmarking framework"
+        }));
+
+var cacheFileName = "BenchmarkCache.json";
+
+var cacheFilePath = Path.join(NodeJs.Path.$$__dirname, cacheFileName);
+
+var saveToCacheFile = Env.Benchmark.SaveDataStrategy.shouldSaveJsonFile(Env.Benchmark.saveDataStrategy) ? (function (data) {
+      var write = function () {
+        var json = S$RescriptSchema.reverseConvertToJsonStringOrThrow(data, schema$4, undefined);
+        return Fs.promises.writeFile(cacheFilePath, json);
+      };
+      Throttler.schedule(throttler, write);
+    }) : (function (param) {
+      
+    });
+
+async function readFromCacheFile() {
+  var content;
+  try {
+    content = await Fs.promises.readFile(cacheFilePath, "utf8");
+  }
+  catch (exn){
+    return ;
+  }
+  try {
+    return S$RescriptSchema.parseJsonStringOrThrow(content, schema$4);
+  }
+  catch (raw_e){
+    var e = Caml_js_exceptions.internalToOCamlException(raw_e);
+    if (e.RE_EXN_ID === S$RescriptSchema.Raised) {
+      Logging.error("Failed to parse benchmark cache file, please delete it and rerun the benchmark");
+      return S$RescriptSchema.$$Error.raise(e._1);
+    }
+    throw e;
+  }
+}
+
+function addSummaryData$1(group, label, value, decimalPlacesOpt) {
+  var decimalPlaces = decimalPlacesOpt !== undefined ? decimalPlacesOpt : 2;
+  addSummaryData(data, group, label, value, decimalPlaces);
+  saveToCacheFile(data);
+}
+
+function incrementMillis$1(label, amount) {
+  incrementMillis(data, label, amount);
+  saveToCacheFile(data);
+}
+
+function addBlockRangeFetched(totalTimeElapsed, parsingTimeElapsed, pageFetchTime, chainId, fromBlock, toBlock, numEvents, numAddresses, queryName) {
+  var group = "BlockRangeFetched Summary for Chain " + String(chainId) + " " + queryName;
+  var add = function (label, value) {
+    addSummaryData(data, group, label, value, undefined);
+  };
+  add("Total Time Elapsed (ms)", totalTimeElapsed);
+  add("Parsing Time Elapsed (ms)", parsingTimeElapsed);
+  add("Page Fetch Time (ms)", pageFetchTime);
+  add("Num Events", numEvents);
+  add("Num Addresses", numAddresses);
+  add("Block Range Size", toBlock - fromBlock | 0);
+  incrementMillis(data, "Total Time Fetching Chain " + String(chainId) + " " + queryName, totalTimeElapsed);
+  saveToCacheFile(data);
+}
+
+var eventProcessingGroup = "EventProcessing Summary";
+
+var batchSizeLabel = "Batch Size";
+
+function addEventProcessing(batchSize, loadDuration, handlerDuration, dbWriteDuration, totalTimeElapsed) {
+  var add = function (label, value) {
+    addSummaryData(data, eventProcessingGroup, label, value, undefined);
+  };
+  add(batchSizeLabel, batchSize);
+  add("Load Duration (ms)", loadDuration);
+  add("Handler Duration (ms)", handlerDuration);
+  add("DB Write Duration (ms)", dbWriteDuration);
+  add("Total Time Elapsed (ms)", totalTimeElapsed);
+  incrementMillis(data, "Total Time Processing", totalTimeElapsed);
+  saveToCacheFile(data);
+}
+
+async function printSummary() {
+  var data = await readFromCacheFile();
+  if (data === undefined) {
+    return Logging.error("No benchmark cache file found, please use 'ENVIO_SAVE_BENCHMARK_DATA=true' and rerun the benchmark");
+  }
+  var summaryData = data.summaryData;
+  var millisAccum = data.millisAccum;
+  console.log("Time breakdown");
+  var timeBreakdown = [[
+      "Total Runtime",
+      DateFns$1.intervalToDuration({
+            start: millisAccum.startTime,
+            end: millisAccum.endTime
+          })
+    ]];
+  Belt_Array.forEach(Js_dict.entries(millisAccum.counters), (function (param) {
+          timeBreakdown.push([
+                param[0],
+                DateFns.durationFromMillis(param[1] | 0)
+              ]);
+        }));
+  console.table(Js_dict.fromArray(timeBreakdown));
+  console.log("General");
+  var batchSizesSum = Belt_Option.getWithDefault(Belt_Option.map(Belt_Option.flatMap(Js_dict.get(summaryData, eventProcessingGroup), (function (g) {
+                  return Js_dict.get(g, batchSizeLabel);
+                })), (function (data) {
+              return data.sum;
+            })), BigDecimal.zero);
+  var totalRuntimeMillis = millisAccum.endTime.getTime() - millisAccum.startTime.getTime();
+  var totalRuntimeSeconds = totalRuntimeMillis / 1000;
+  var eventsPerSecond = batchSizesSum.dividedBy(new BignumberJs(totalRuntimeSeconds)).decimalPlaces(2).toNumber();
+  console.table({
+        "batch sizes sum": batchSizesSum.toNumber(),
+        "total runtime (sec)": totalRuntimeSeconds,
+        "events per second": eventsPerSecond
+      });
+  return Belt_Array.forEach(Js_dict.entries(summaryData).sort(function (param, param$1) {
+                  if (param[0] < param$1[0]) {
+                    return -1;
+                  } else {
+                    return 1;
+                  }
+                }), (function (param) {
+                console.log(param[0]);
+                console.table(Js_dict.fromArray(Belt_Array.map(Js_dict.entries(param[1]), (function (param) {
+                                return [
+                                        param[0],
+                                        makeFromDataSet(param[1])
+                                      ];
+                              }))));
+              }));
+}
+
+var Summary = {
+  printSummary: printSummary
+};
+
+export {
+  MillisAccum ,
+  SummaryData ,
+  Stats ,
+  Data ,
+  data ,
+  throttler ,
+  cacheFileName ,
+  cacheFilePath ,
+  saveToCacheFile ,
+  readFromCacheFile ,
+  addSummaryData$1 as addSummaryData,
+  incrementMillis$1 as incrementMillis,
+  addBlockRangeFetched ,
+  eventProcessingGroup ,
+  batchSizeLabel ,
+  addEventProcessing ,
+  Summary ,
+}
+/* schema Not a pure module */