envio 3.12.1 → 3.13.0-alpha.0

package/src/Server.res

@@ -0,0 +1,181 @@
+// The indexer's own HTTP surface: metrics for a scraper, health for an
+// orchestrator, and the console's view of the run. What it serves is handed to
+// it, so one process's readings and a supervised group's merged ones render the
+// same way.
+
+// The public console/state chain shape. Kept to exactly this field set for
+// backward compatibility with consumers like RACE — new metric fields stay off
+// the HTTP response.
+type chainData = {
+  chainId: ChainId.t,
+  poweredByHyperSync: bool,
+  firstEventBlockNumber: option<int>,
+  latestProcessedBlock: option<int>,
+  timestampCaughtUpToHeadOrEndblock: option<Date.t>,
+  numEventsProcessed: float,
+  latestFetchedBlockNumber: int,
+  // Need this for API backwards compatibility
+  @as("currentBlockHeight")
+  knownHeight: int,
+  numBatchesFetched: int,
+  startBlock: int,
+  endBlock: option<int>,
+  numAddresses: int,
+}
+@tag("status")
+type state =
+  | @as("disabled") Disabled({})
+  | @as("initializing") Initializing({})
+  | @as("active")
+  Active({
+      envioVersion: string,
+      chains: array<chainData>,
+      indexerStartTime: Date.t,
+      isPreRegisteringDynamicContracts: bool,
+      rollbackOnReorg: bool,
+    })
+
+let toChainData = (m: Metrics.chainMetrics): chainData => {
+  chainId: m.chainId,
+  poweredByHyperSync: m.poweredByHyperSync,
+  firstEventBlockNumber: m.firstEventBlockNumber,
+  latestProcessedBlock: m.latestProcessedBlock,
+  timestampCaughtUpToHeadOrEndblock: m.timestampCaughtUpToHeadOrEndblock,
+  numEventsProcessed: m.numEventsProcessed,
+  latestFetchedBlockNumber: m.latestFetchedBlockNumber,
+  knownHeight: m.knownHeight,
+  numBatchesFetched: m.numBatchesFetched,
+  startBlock: m.startBlock,
+  endBlock: m.endBlock,
+  numAddresses: m.numAddresses,
+}
+
+let chainDataSchema = S.schema((s): chainData => {
+  chainId: s.matches(ChainId.schema),
+  poweredByHyperSync: s.matches(S.bool),
+  firstEventBlockNumber: s.matches(S.option(S.int)),
+  latestProcessedBlock: s.matches(S.option(S.int)),
+  timestampCaughtUpToHeadOrEndblock: s.matches(S.option(S.datetime(S.string))),
+  numEventsProcessed: s.matches(S.float),
+  latestFetchedBlockNumber: s.matches(S.int),
+  knownHeight: s.matches(S.int),
+  numBatchesFetched: s.matches(S.int),
+  startBlock: s.matches(S.int),
+  endBlock: s.matches(S.option(S.int)),
+  numAddresses: s.matches(S.int),
+})
+let stateSchema = S.union([
+  S.literal(Disabled({})),
+  S.literal(Initializing({})),
+  S.schema(s => Active({
+    envioVersion: s.matches(S.string),
+    chains: s.matches(S.array(chainDataSchema)),
+    indexerStartTime: s.matches(S.datetime(S.string)),
+    // Keep the field, since Dev Console expects it to be present
+    isPreRegisteringDynamicContracts: false,
+    rollbackOnReorg: s.matches(S.bool),
+  })),
+])
+
+// Runtime state lives in the process-wide `EnvioGlobal` record (shared
+// across duplicate envio module instances); the slots are opaque there, so
+// cast them to the real types here.
+let startServer = (
+  ~getMetrics: unit => option<Metrics.t>,
+  ~envioVersion: string,
+  ~onSyncCache: unit => promise<unit>,
+  ~collectRuntime: unit => string,
+  ~isDevelopmentMode: bool,
+) => {
+  open Express
+
+  let app = make()
+
+  let consoleCorsMiddleware = (req, res, next) => {
+    switch req.headers->Dict.get("origin") {
+    | Some(origin) if origin === Env.prodEnvioAppUrl || origin === Env.envioAppUrl =>
+      res->setHeader("Access-Control-Allow-Origin", origin)
+    | _ => ()
+    }
+
+    res->setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
+    res->setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept")
+
+    if req.method === Rest.Options {
+      res->sendStatus(200)
+    } else {
+      next()
+    }
+  }
+  app->useFor("/console", consoleCorsMiddleware)
+  app->useFor("/metrics", consoleCorsMiddleware)
+  app->useFor("/metrics/runtime", consoleCorsMiddleware)
+
+  app->get("/healthz", (_req, res) => {
+    // this is the machine readable port used in kubernetes to check the health of this service.
+    //   aditional health information could be added in the future (info about errors, back-offs, etc).
+    res->sendStatus(200)
+  })
+
+  app->get("/console/state", (_req, res) => {
+    let state = if !isDevelopmentMode {
+      Disabled({})
+    } else {
+      switch getMetrics() {
+      | None => Initializing({})
+      | Some(metrics) =>
+        Active({
+          envioVersion,
+          chains: metrics.chains->Array.map(toChainData),
+          indexerStartTime: metrics.startTime,
+          isPreRegisteringDynamicContracts: false,
+          rollbackOnReorg: metrics.rollbackEnabled,
+        })
+      }
+    }
+
+    res->json(state->S.reverseConvertToJsonOrThrow(stateSchema))
+  })
+
+  app->post("/console/syncCache", (_req, res) => {
+    if isDevelopmentMode {
+      onSyncCache()
+      ->Promise.thenResolve(() => res->json(Boolean(true)))
+      // A dump that couldn't be made, or couldn't be confirmed, answers the
+      // same `false` a disabled console does. Leaving it unanswered would hold
+      // the request open for as long as the indexer runs.
+      ->Promise.catch(exn => {
+        Logging.errorWithExn(exn, "Failed to sync the effect cache")
+        res->json(Boolean(false))
+        Promise.resolve()
+      })
+      ->Promise.ignore
+    } else {
+      res->json(Boolean(false))
+    }
+  })
+
+  app->get("/metrics", (_req, res) => {
+    res->set("Content-Type", Metrics.contentType)
+    let _ = res->endWithData(Metrics.collect(~metrics=getMetrics()))
+  })
+
+  app->get("/metrics/runtime", (_req, res) => {
+    res->set("Content-Type", Metrics.contentType)
+    let _ = res->endWithData(collectRuntime())
+  })
+
+  let server = app->listen(Env.serverPort)
+  server->Express.onError(err => {
+    let code = (err->(Utils.magic: JsExn.t => {..}))["code"]
+    if code === "EADDRINUSE" {
+      Logging.error(
+        `Port ${Env.serverPort->Int.toString} is already in use. To fix this either:` ++
+        `\n  1. Kill the process using the port: lsof -ti :${Env.serverPort->Int.toString} | xargs kill -9` ++ `\n  2. Use a different port by setting the ENVIO_INDEXER_PORT environment variable: ENVIO_INDEXER_PORT=9899 envio start`,
+      )
+    } else {
+      Logging.errorWithExn(err, "Failed to start indexer server")
+    }
+    NodeJs.process->NodeJs.exitWithCode(Failure)
+  })
+}

package/src/Server.res.mjs

@@ -0,0 +1,143 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Env from "./Env.res.mjs";
+import * as ChainId from "./ChainId.res.mjs";
+import * as Logging from "./Logging.res.mjs";
+import * as Metrics from "./Metrics.res.mjs";
+import Express from "express";
+import * as Process from "process";
+import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+function toChainData(m) {
+  return {
+    chainId: m.chainId,
+    poweredByHyperSync: m.poweredByHyperSync,
+    firstEventBlockNumber: m.firstEventBlockNumber,
+    latestProcessedBlock: m.latestProcessedBlock,
+    timestampCaughtUpToHeadOrEndblock: m.timestampCaughtUpToHeadOrEndblock,
+    numEventsProcessed: m.numEventsProcessed,
+    latestFetchedBlockNumber: m.latestFetchedBlockNumber,
+    currentBlockHeight: m.knownHeight,
+    numBatchesFetched: m.numBatchesFetched,
+    startBlock: m.startBlock,
+    endBlock: m.endBlock,
+    numAddresses: m.numAddresses
+  };
+}
+
+let chainDataSchema = S$RescriptSchema.schema(s => ({
+  chainId: s.m(ChainId.schema),
+  poweredByHyperSync: s.m(S$RescriptSchema.bool),
+  firstEventBlockNumber: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
+  latestProcessedBlock: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
+  timestampCaughtUpToHeadOrEndblock: s.m(S$RescriptSchema.option(S$RescriptSchema.datetime(S$RescriptSchema.string, undefined))),
+  numEventsProcessed: s.m(S$RescriptSchema.float),
+  latestFetchedBlockNumber: s.m(S$RescriptSchema.int),
+  currentBlockHeight: s.m(S$RescriptSchema.int),
+  numBatchesFetched: s.m(S$RescriptSchema.int),
+  startBlock: s.m(S$RescriptSchema.int),
+  endBlock: s.m(S$RescriptSchema.option(S$RescriptSchema.int)),
+  numAddresses: s.m(S$RescriptSchema.int)
+}));
+
+let stateSchema = S$RescriptSchema.union([
+  S$RescriptSchema.literal({
+    status: "disabled"
+  }),
+  S$RescriptSchema.literal({
+    status: "initializing"
+  }),
+  S$RescriptSchema.schema(s => ({
+    status: "active",
+    envioVersion: s.m(S$RescriptSchema.string),
+    chains: s.m(S$RescriptSchema.array(chainDataSchema)),
+    indexerStartTime: s.m(S$RescriptSchema.datetime(S$RescriptSchema.string, undefined)),
+    isPreRegisteringDynamicContracts: false,
+    rollbackOnReorg: s.m(S$RescriptSchema.bool)
+  }))
+]);
+
+function startServer(getMetrics, envioVersion, onSyncCache, collectRuntime, isDevelopmentMode) {
+  let app = Express();
+  let consoleCorsMiddleware = (req, res, next) => {
+    let origin = req.headers["origin"];
+    if (origin !== undefined && (origin === Env.prodEnvioAppUrl || origin === Env.envioAppUrl)) {
+      res.setHeader("Access-Control-Allow-Origin", origin);
+    }
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
+    if (req.method === "OPTIONS") {
+      res.sendStatus(200);
+      return;
+    } else {
+      return next();
+    }
+  };
+  app.use("/console", consoleCorsMiddleware);
+  app.use("/metrics", consoleCorsMiddleware);
+  app.use("/metrics/runtime", consoleCorsMiddleware);
+  app.get("/healthz", (_req, res) => {
+    res.sendStatus(200);
+  });
+  app.get("/console/state", (_req, res) => {
+    let state;
+    if (isDevelopmentMode) {
+      let metrics = getMetrics();
+      state = metrics !== undefined ? ({
+          status: "active",
+          envioVersion: envioVersion,
+          chains: metrics.chains.map(toChainData),
+          indexerStartTime: metrics.startTime,
+          isPreRegisteringDynamicContracts: false,
+          rollbackOnReorg: metrics.rollbackEnabled
+        }) : ({
+          status: "initializing"
+        });
+    } else {
+      state = {
+        status: "disabled"
+      };
+    }
+    res.json(S$RescriptSchema.reverseConvertToJsonOrThrow(state, stateSchema));
+  });
+  app.post("/console/syncCache", (_req, res) => {
+    if (isDevelopmentMode) {
+      Stdlib_Promise.$$catch(onSyncCache().then(() => {
+        res.json(true);
+      }), exn => {
+        Logging.errorWithExn(exn, "Failed to sync the effect cache");
+        res.json(false);
+        return Promise.resolve();
+      });
+    } else {
+      res.json(false);
+    }
+  });
+  app.get("/metrics", (_req, res) => {
+    res.set("Content-Type", Metrics.contentType);
+    res.end(Metrics.collect(getMetrics()));
+  });
+  app.get("/metrics/runtime", (_req, res) => {
+    res.set("Content-Type", Metrics.contentType);
+    res.end(collectRuntime());
+  });
+  let server = app.listen(Env.serverPort);
+  server.on("error", err => {
+    let code = err.code;
+    if (code === "EADDRINUSE") {
+      Logging.error(`Port ` + Env.serverPort.toString() + ` is already in use. To fix this either:` + (`\n  1. Kill the process using the port: lsof -ti :` + Env.serverPort.toString() + ` | xargs kill -9`) + `\n  2. Use a different port by setting the ENVIO_INDEXER_PORT environment variable: ENVIO_INDEXER_PORT=9899 envio start`);
+    } else {
+      Logging.errorWithExn(err, "Failed to start indexer server");
+    }
+    Process.exit(1);
+  });
+}
+
+export {
+  toChainData,
+  chainDataSchema,
+  stateSchema,
+  startServer,
+}
+/* chainDataSchema Not a pure module */