@lodestar/beacon-node 1.35.0-dev.f80d2d52da → 1.35.0-dev.fd1dac853d

package/src/metrics/metrics.ts

@@ -0,0 +1,43 @@
+import {Metric, Registry} from "prom-client";
+import {ForkChoiceMetrics, getForkChoiceMetrics} from "@lodestar/fork-choice";
+import {BeaconStateTransitionMetrics, getMetrics} from "@lodestar/state-transition";
+import {BeaconMetrics, createBeaconMetrics} from "./metrics/beacon.js";
+import {LodestarMetrics, createLodestarMetrics} from "./metrics/lodestar.js";
+import {collectNodeJSMetrics} from "./nodeJsMetrics.js";
+import {MetricsOptions} from "./options.js";
+import {RegistryMetricCreator} from "./utils/registryMetricCreator.js";
+
+export type Metrics = BeaconMetrics &
+  ForkChoiceMetrics &
+  BeaconStateTransitionMetrics &
+  LodestarMetrics & {register: RegistryMetricCreator; close: () => void};
+
+export function createMetrics(opts: MetricsOptions, genesisTime: number, externalRegistries: Registry[] = []): Metrics {
+  const register = new RegistryMetricCreator();
+  const beacon = createBeaconMetrics(register);
+  const forkChoice = getForkChoiceMetrics(register);
+  const lodestar = createLodestarMetrics(register, opts.metadata, genesisTime);
+  const stateTransition = getMetrics(register);
+
+  process.on("unhandledRejection", (_error) => {
+    lodestar.unhandledPromiseRejections.inc();
+  });
+
+  const close = collectNodeJSMetrics(register);
+
+  // Merge external registries
+  for (const externalRegister of externalRegistries) {
+    for (const metric of externalRegister.getMetricsAsArray()) {
+      register.registerMetric(metric as unknown as Metric<string>);
+    }
+  }
+
+  return {
+    ...beacon,
+    ...forkChoice,
+    ...lodestar,
+    ...stateTransition,
+    register,
+    close,
+  };
+}

package/src/metrics/nodeJsMetrics.ts

@@ -0,0 +1,19 @@
+import {Registry, collectDefaultMetrics} from "prom-client";
+import {gcStats} from "#prometheus-gc-stats-wrapper";
+
+export function collectNodeJSMetrics(register: Registry, prefix?: string): () => void {
+  collectDefaultMetrics({
+    register,
+    prefix,
+    // eventLoopMonitoringPrecision with sampling rate in milliseconds
+    eventLoopMonitoringPrecision: 10,
+  });
+
+  // Collects GC metrics using a native binding module
+  // - nodejs_gc_runs_total: Counts the number of time GC is invoked
+  // - nodejs_gc_pause_seconds_total: Time spent in GC in seconds
+  // - nodejs_gc_reclaimed_bytes_total: The number of bytes GC has freed
+  // `close` must be called to stop the gc collection process from continuing
+  const close = gcStats(register, {collectionInterval: 6000, prefix});
+  return close;
+}

package/src/metrics/options.ts

@@ -0,0 +1,22 @@
+import {HttpMetricsServerOpts} from "./server/index.js";
+
+export type LodestarMetadata = {
+  /** "v0.16.0/developer/feature-1/ac99f2b5" */
+  version: string;
+  /** "4f816b16dfde718e2d74f95f2c8292596138c248" */
+  commit: string;
+  /** "hoodi" */
+  network: string;
+};
+
+export type MetricsOptions = HttpMetricsServerOpts & {
+  enabled: boolean;
+  /** Optional metadata to send to Prometheus */
+  metadata?: LodestarMetadata;
+};
+
+export const defaultMetricsOptions: MetricsOptions = {
+  enabled: false,
+  port: 8008,
+  address: "127.0.0.1",
+};

package/src/metrics/server/http.ts

@@ -0,0 +1,114 @@
+import http from "node:http";
+import {AddressInfo} from "node:net";
+import {Registry} from "prom-client";
+import {Logger} from "@lodestar/utils";
+import {HttpActiveSocketsTracker} from "../../api/rest/activeSockets.js";
+import {wrapError} from "../../util/wrapError.js";
+import {RegistryMetricCreator} from "../utils/registryMetricCreator.js";
+
+export type HttpMetricsServerOpts = {
+  port: number;
+  address?: string;
+};
+
+export type HttpMetricsServer = {
+  close(): Promise<void>;
+};
+
+enum RequestStatus {
+  success = "success",
+  error = "error",
+}
+
+export async function getHttpMetricsServer(
+  opts: HttpMetricsServerOpts,
+  {
+    register,
+    getOtherMetrics = async () => [],
+    logger,
+  }: {register: Registry; getOtherMetrics?: () => Promise<string[]>; logger: Logger}
+): Promise<HttpMetricsServer> {
+  // New registry to metric the metrics. Using the same registry would deadlock the .metrics promise
+  const httpServerRegister = new RegistryMetricCreator();
+
+  const scrapeTimeMetric = httpServerRegister.histogram<{status: RequestStatus}>({
+    name: "lodestar_metrics_scrape_seconds",
+    help: "Lodestar metrics server async time to scrape metrics",
+    labelNames: ["status"],
+    buckets: [0.1, 1, 10],
+  });
+
+  const server = http.createServer(async function onRequest(
+    req: http.IncomingMessage,
+    res: http.ServerResponse
+  ): Promise<void> {
+    if (req.method === "GET" && req.url && req.url.includes("/metrics")) {
+      const timer = scrapeTimeMetric.startTimer();
+      const metricsRes = await Promise.all([wrapError(register.metrics()), getOtherMetrics()]);
+      timer({status: metricsRes[0].err ? RequestStatus.error : RequestStatus.success});
+
+      // Ensure we only writeHead once
+      if (metricsRes[0].err) {
+        res.writeHead(500, {"content-type": "text/plain"}).end(metricsRes[0].err.stack);
+      } else {
+        // Get scrape time metrics
+        const httpServerMetrics = await httpServerRegister.metrics();
+        const metrics = [metricsRes[0].result, httpServerMetrics, ...metricsRes[1]];
+        const metricsStr = metrics.join("\n\n");
+        res.writeHead(200, {"content-type": register.contentType}).end(metricsStr);
+      }
+    } else {
+      res.writeHead(404).end();
+    }
+  });
+
+  const socketsMetrics = {
+    activeSockets: httpServerRegister.gauge({
+      name: "lodestar_metrics_server_active_sockets_count",
+      help: "Metrics server current count of active sockets",
+    }),
+    socketsBytesRead: httpServerRegister.gauge({
+      name: "lodestar_metrics_server_sockets_bytes_read_total",
+      help: "Metrics server total count of bytes read on all sockets",
+    }),
+    socketsBytesWritten: httpServerRegister.gauge({
+      name: "lodestar_metrics_server_sockets_bytes_written_total",
+      help: "Metrics server total count of bytes written on all sockets",
+    }),
+  };
+
+  const activeSockets = new HttpActiveSocketsTracker(server, socketsMetrics);
+
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", (err) => {
+      logger.error("Error starting metrics HTTP server", opts, err);
+      reject(err);
+    });
+    server.listen(opts.port, opts.address, () => {
+      const {port, address: host, family} = server.address() as AddressInfo;
+      const address = `http://${family === "IPv6" ? `[${host}]` : host}:${port}`;
+      logger.info("Started metrics HTTP server", {address});
+      resolve();
+    });
+  });
+
+  return {
+    async close(): Promise<void> {
+      // In NodeJS land calling close() only causes new connections to be rejected.
+      // Existing connections can prevent .close() from resolving for potentially forever.
+      // In Lodestar case when the BeaconNode wants to close we will attempt to gracefully
+      // close all existing connections but forcefully terminate after timeout for a fast shutdown.
+      // Inspired by https://github.com/gajus/http-terminator/
+      await activeSockets.terminate();
+
+      await new Promise<void>((resolve, reject) => {
+        server.close((err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+
+      logger.debug("Metrics HTTP server closed");
+    },
+  };
+}

package/src/metrics/server/index.ts

@@ -0,0 +1 @@
+export * from "./http.js";

package/src/metrics/utils/avgMinMax.ts

@@ -0,0 +1,87 @@
+import {GaugeConfiguration} from "prom-client";
+import {AvgMinMax as IAvgMinMax, LabelKeys, LabelsGeneric} from "@lodestar/utils";
+import {GaugeExtra} from "./gauge.js";
+
+type GetValuesFn = () => number[];
+
+/**
+ * Special non-standard "Histogram" that captures the avg, min and max of values
+ */
+export class AvgMinMax<Labels extends LabelsGeneric> implements IAvgMinMax<Labels> {
+  private readonly sum: GaugeExtra<Labels>;
+  private readonly avg: GaugeExtra<Labels>;
+  private readonly min: GaugeExtra<Labels>;
+  private readonly max: GaugeExtra<Labels>;
+
+  private getValuesFn: GetValuesFn | null = null;
+
+  constructor(configuration: GaugeConfiguration<LabelKeys<Labels>>) {
+    this.sum = new GaugeExtra({...configuration, name: `${configuration.name}_sum`});
+    this.avg = new GaugeExtra({...configuration, name: `${configuration.name}_avg`});
+    this.min = new GaugeExtra({...configuration, name: `${configuration.name}_min`});
+    this.max = new GaugeExtra({...configuration, name: `${configuration.name}_max`});
+  }
+
+  addGetValuesFn(getValuesFn: GetValuesFn): void {
+    if (this.getValuesFn === null) {
+      this.getValuesFn = getValuesFn;
+
+      this.avg.addCollect(this.onCollect);
+    } else {
+      throw Error("Already registered a getValuesFn");
+    }
+  }
+
+  set(values: number[]): void;
+  set(labels: Labels, values: number[]): void;
+  set(arg1?: Labels | number[], arg2?: number[]): void {
+    if (arg2 === undefined) {
+      const values = arg1 as number[];
+      const {sum, avg, min, max} = getStats(values);
+      this.sum.set(sum);
+      this.avg.set(avg);
+      this.min.set(min);
+      this.max.set(max);
+    } else {
+      const values = (arg2 !== undefined ? arg2 : arg1) as number[];
+      const labels = arg1 as Labels;
+      const {sum, avg, min, max} = getStats(values);
+      this.sum.set(labels, sum);
+      this.avg.set(labels, avg);
+      this.min.set(labels, min);
+      this.max.set(labels, max);
+    }
+  }
+
+  private onCollect = (): void => {
+    if (this.getValuesFn !== null) {
+      this.set(this.getValuesFn());
+    }
+  };
+}
+
+type ArrStatistics = {
+  sum: number;
+  avg: number;
+  min: number;
+  max: number;
+};
+
+function getStats(values: number[]): ArrStatistics {
+  if (values.length < 1) {
+    return {sum: 0, avg: 0, min: 0, max: 0};
+  }
+
+  let min = values[0];
+  let max = values[0];
+  let sum = values[0];
+
+  for (let i = 1; i < values.length; i++) {
+    const val = values[i];
+    if (val < min) min = val;
+    if (val > max) max = val;
+    sum += val;
+  }
+
+  return {sum, avg: sum / values.length, min, max};
+}

package/src/metrics/utils/gauge.ts

@@ -0,0 +1,22 @@
+import {Gauge} from "prom-client";
+import {CollectFn, Gauge as IGauge, LabelKeys, LabelsGeneric} from "@lodestar/utils";
+
+/**
+ * Extends the prom-client Gauge to be able to add multiple collect functions after instantiation
+ */
+export class GaugeExtra<Labels extends LabelsGeneric> extends Gauge<LabelKeys<Labels>> implements IGauge<Labels> {
+  private collectFns: CollectFn<Labels>[] = [];
+
+  addCollect(collectFn: CollectFn<Labels>): void {
+    this.collectFns.push(collectFn);
+  }
+
+  /**
+   * @override Metric.collect
+   */
+  collect(): void {
+    for (const collectFn of this.collectFns) {
+      collectFn(this);
+    }
+  }
+}

package/src/metrics/utils/registryMetricCreator.ts

@@ -0,0 +1,41 @@
+import {Counter, Gauge, Histogram, Registry} from "prom-client";
+import {
+  AvgMinMaxConfig,
+  CounterConfig,
+  GaugeConfig,
+  HistogramConfig,
+  AvgMinMax as IAvgMinMax,
+  Counter as ICounter,
+  GaugeExtra as IGaugeExtra,
+  Histogram as IHistogram,
+  LabelKeys,
+  LabelsGeneric,
+  MetricsRegisterCustom,
+  NoLabels,
+  StaticConfig,
+} from "@lodestar/utils";
+import {AvgMinMax} from "./avgMinMax.js";
+import {GaugeExtra} from "./gauge.js";
+
+export class RegistryMetricCreator extends Registry implements MetricsRegisterCustom {
+  gauge<Labels extends LabelsGeneric = NoLabels>(configuration: GaugeConfig<Labels>): IGaugeExtra<Labels> {
+    return new GaugeExtra<Labels>({...configuration, registers: [this]});
+  }
+
+  histogram<Labels extends LabelsGeneric = NoLabels>(configuration: HistogramConfig<Labels>): IHistogram<Labels> {
+    return new Histogram<LabelKeys<Labels>>({...configuration, registers: [this]});
+  }
+
+  avgMinMax<Labels extends LabelsGeneric = NoLabels>(configuration: AvgMinMaxConfig<Labels>): IAvgMinMax<Labels> {
+    return new AvgMinMax<Labels>({...configuration, registers: [this]});
+  }
+
+  /** Static metric to send string-based data such as versions, config params, etc */
+  static<Labels extends LabelsGeneric = NoLabels>({name, help, value}: StaticConfig<Labels>): void {
+    new Gauge({name, help, labelNames: Object.keys(value), registers: [this]}).set(value, 1);
+  }
+
+  counter<Labels extends LabelsGeneric = NoLabels>(configuration: CounterConfig<Labels>): ICounter<Labels> {
+    return new Counter<LabelKeys<Labels>>({...configuration, registers: [this]});
+  }
+}

package/src/monitoring/clientStats.ts

@@ -0,0 +1,297 @@
+import {DynamicProperty, MetricProperty, StaticProperty} from "./properties.js";
+import {Client} from "./service.js";
+import system from "./system.js";
+import {ClientStats, JsonType, ProcessType} from "./types.js";
+
+// Definition of client stats based on specification
+// See https://docs.google.com/document/d/1qPWAVRjPCENlyAjUBwGkHMvz9qLdd_6u9DPZcNxDBpc
+
+const CLIENT_STATS_SPEC_VERSION = 1;
+
+const CLIENT_NAME = "lodestar";
+
+export function createClientStats(client: Client, collectSystemStats?: boolean): ClientStats[] {
+  const clientStats = [];
+
+  if (client === "beacon") {
+    clientStats.push(createBeaconNodeStats());
+  } else if (client === "validator") {
+    clientStats.push(createValidatorStats());
+  }
+
+  if (collectSystemStats) {
+    clientStats.push(createSystemStats());
+  }
+
+  return clientStats;
+}
+
+function createCommonStats(process: ProcessType): ClientStats {
+  return {
+    version: new StaticProperty({
+      jsonKey: "version",
+      value: CLIENT_STATS_SPEC_VERSION,
+      description: "Client Stats data specification version",
+    }),
+    timestamp: new DynamicProperty({
+      jsonKey: "timestamp",
+      provider: Date.now,
+      description: "Unix timestamp in milliseconds",
+    }),
+    process: new StaticProperty({
+      jsonKey: "process",
+      value: process,
+      description: "Process type, can be one of: validator, beaconnode, system",
+    }),
+  };
+}
+
+function createProcessStats(process: ProcessType): ClientStats {
+  return {
+    ...createCommonStats(process),
+    cpuProcessSecondsTotal: new MetricProperty({
+      jsonKey: "cpu_process_seconds_total",
+      metricName: "process_cpu_user_seconds_total",
+      jsonType: JsonType.Number,
+      defaultValue: 0,
+      description: "CPU seconds consumed by the process",
+    }),
+    memoryProcessBytes: new MetricProperty({
+      jsonKey: "memory_process_bytes",
+      metricName: "process_resident_memory_bytes",
+      jsonType: JsonType.Number,
+      defaultValue: 0,
+      description: "Amount of memory in bytes allocated to the process",
+    }),
+    clientName: new StaticProperty({
+      jsonKey: "client_name",
+      value: CLIENT_NAME,
+      description: "Name of client, e.g. lodestar, prysm, lighthouse, teku, nimbus, grandine",
+    }),
+    clientVersion: new MetricProperty({
+      jsonKey: "client_version",
+      metricName: "lodestar_version",
+      fromLabel: "version",
+      formatter: (value) => {
+        // remove "v" prefix from value
+        return (value as string).substring(1);
+      },
+      jsonType: JsonType.String,
+      cacheResult: true,
+      defaultValue: "",
+      description: "Version of client, e.g. 1.3.0/2d0938e",
+    }),
+    clientBuild: new StaticProperty({
+      jsonKey: "client_build",
+      value: 0,
+      description: "Incrementing integer representation of build for easier comparison",
+    }),
+    syncEth2FallbackConfigured: new StaticProperty({
+      jsonKey: "sync_eth2_fallback_configured",
+      value: false,
+      description: "Whether the client has a fallback eth2 endpoint configured",
+    }),
+    syncEth2FallbackConnected: new StaticProperty({
+      jsonKey: "sync_eth2_fallback_connected",
+      value: false,
+      description: "Whether the client is currently connected to a fallback eth2 endpoint",
+    }),
+  };
+}
+
+function createBeaconNodeStats(): ClientStats {
+  return {
+    ...createProcessStats(ProcessType.BeaconNode),
+    diskBeaconChainBytesTotal: new MetricProperty({
+      jsonKey: "disk_beaconchain_bytes_total",
+      metricName: "lodestar_db_size_bytes_total",
+      jsonType: JsonType.Number,
+      defaultValue: 0,
+      description: "Amount of bytes consumed on disk by the beacon node's database",
+    }),
+    networkLibp2pBytesTotalReceive: new MetricProperty({
+      jsonKey: "network_libp2p_bytes_total_receive",
+      metricName: "libp2p_data_transfer_bytes_total",
+      withLabel: {name: "protocol", value: "global received"},
+      jsonType: JsonType.Number,
+      defaultValue: 0,
+      description: "Number of bytes received via libp2p traffic",
+    }),
+    networkLibp2pBytesTotalTransmit: new MetricProperty({
+      jsonKey: "network_libp2p_bytes_total_transmit",
+      metricName: "libp2p_data_transfer_bytes_total",
+      withLabel: {name: "protocol", value: "global sent"},
+      jsonType: JsonType.Number,
+      defaultValue: 0,
+      description: "Number of bytes transmitted via libp2p traffic",
+    }),
+    networkPeersConnected: new MetricProperty({
+      jsonKey: "network_peers_connected",
+      metricName: "libp2p_peers",
+      jsonType: JsonType.Number,
+      defaultValue: 0,
+      description: "Number of connected peers",
+    }),
+    syncEth1Connected: new MetricProperty({
+      jsonKey: "sync_eth1_connected",
+      metricName: "lodestar_execution_engine_http_client_config_urls_count",
+      jsonType: JsonType.Boolean,
+      defaultValue: false,
+      description: "Whether the beacon node is connected to a eth1 node",
+    }),
+    syncEth2Synced: new MetricProperty({
+      jsonKey: "sync_eth2_synced",
+      metricName: "lodestar_sync_status",
+      rangeValue: 3,
+      jsonType: JsonType.Boolean,
+      defaultValue: true,
+      description: "Whether the beacon node is in sync with the beacon chain network",
+    }),
+    syncBeaconHeadSlot: new MetricProperty({
+      jsonKey: "sync_beacon_head_slot",
+      metricName: "beacon_head_slot",
+      jsonType: JsonType.Number,
+      defaultValue: 0,
+      description: "Slot of the head block of the beacon chain",
+    }),
+    syncEth1FallbackConfigured: new MetricProperty({
+      jsonKey: "sync_eth1_fallback_configured",
+      metricName: "lodestar_execution_engine_http_client_config_urls_count",
+      threshold: 2,
+      jsonType: JsonType.Boolean,
+      defaultValue: false,
+      description: "Whether the beacon node has a fallback eth1 endpoint configured",
+    }),
+    syncEth1FallbackConnected: new StaticProperty({
+      jsonKey: "sync_eth1_fallback_connected",
+      value: false,
+      description: "Whether the beacon node is currently connected to a fallback eth1 endpoint",
+    }),
+    slasherActive: new StaticProperty({
+      jsonKey: "slasher_active",
+      value: false,
+      description: "Whether slasher functionality is enabled",
+    }),
+  };
+}
+
+function createValidatorStats(): ClientStats {
+  return {
+    ...createProcessStats(ProcessType.Validator),
+    validatorTotal: new MetricProperty({
+      jsonKey: "validator_total",
+      metricName: "vc_indices_count",
+      jsonType: JsonType.Number,
+      defaultValue: 0,
+      description: "Number of validator keys in use",
+    }),
+    validatorActive: new MetricProperty({
+      jsonKey: "validator_active",
+      metricName: "vc_indices_count",
+      jsonType: JsonType.Number,
+      defaultValue: 0,
+      description: "Number of validator keys that are currently active",
+    }),
+  };
+}
+
+function createSystemStats(): ClientStats {
+  return {
+    ...createCommonStats(ProcessType.System),
+    cpuCores: new DynamicProperty({
+      jsonKey: "cpu_cores",
+      provider: () => system.cpuCores,
+      description: "Number of CPU cores available",
+    }),
+    cpuThreads: new DynamicProperty({
+      jsonKey: "cpu_threads",
+      provider: () => system.cpuThreads,
+      description: "Number of CPU threads available",
+    }),
+    cpuNodeSystemSecondsTotal: new DynamicProperty({
+      jsonKey: "cpu_node_system_seconds_total",
+      provider: () => system.cpuNodeSystemSecondsTotal,
+      description: "CPU seconds consumed by all processes",
+    }),
+    cpuNodeUserSecondsTotal: new DynamicProperty({
+      jsonKey: "cpu_node_user_seconds_total",
+      provider: () => system.cpuNodeUserSecondsTotal,
+      description: "CPU seconds consumed by user processes",
+    }),
+    cpuNodeIOWaitSecondsTotal: new DynamicProperty({
+      jsonKey: "cpu_node_iowait_seconds_total",
+      provider: () => system.cpuNodeIOWaitSecondsTotal,
+      description: "CPU seconds spent in I/O wait state",
+    }),
+    cpuNodeIdleSecondsTotal: new DynamicProperty({
+      jsonKey: "cpu_node_idle_seconds_total",
+      provider: () => system.cpuNodeIdleSecondsTotal,
+      description: "CPU seconds spent in idle state",
+    }),
+    memoryNodeBytesTotal: new DynamicProperty({
+      jsonKey: "memory_node_bytes_total",
+      provider: () => system.memoryNodeBytesTotal,
+      description: "Total amount of memory in bytes available",
+    }),
+    memoryNodeBytesFree: new DynamicProperty({
+      jsonKey: "memory_node_bytes_free",
+      provider: () => system.memoryNodeBytesFree,
+      description: "Amount of free memory in bytes",
+    }),
+    memoryNodeBytesCached: new DynamicProperty({
+      jsonKey: "memory_node_bytes_cached",
+      provider: () => system.memoryNodeBytesCached,
+      description: "Amount of memory in bytes used by cache",
+    }),
+    memoryNodeBytesBuffers: new DynamicProperty({
+      jsonKey: "memory_node_bytes_buffers",
+      provider: () => system.memoryNodeBytesBuffers,
+      description: "Amount of memory in bytes used by buffers",
+    }),
+    diskNodeBytesTotal: new DynamicProperty({
+      jsonKey: "disk_node_bytes_total",
+      provider: () => system.diskNodeBytesTotal,
+      description: "Total amount of available disk space in bytes",
+    }),
+    diskNodeBytesFree: new DynamicProperty({
+      jsonKey: "disk_node_bytes_free",
+      provider: () => system.diskNodeBytesFree,
+      description: "Amount of free disk space in bytes",
+    }),
+    diskNodeIOSeconds: new DynamicProperty({
+      jsonKey: "disk_node_io_seconds",
+      provider: () => system.diskNodeIOSeconds,
+      description: "Total time spent in seconds on disk I/O operations",
+    }),
+    diskNodeReadsTotal: new DynamicProperty({
+      jsonKey: "disk_node_reads_total",
+      provider: () => system.diskNodeReadsTotal,
+      description: "Total number of disk read I/O operations",
+    }),
+    diskNodeWritesTotal: new DynamicProperty({
+      jsonKey: "disk_node_writes_total",
+      provider: () => system.diskNodeWritesTotal,
+      description: "Total number of disk write I/O operations",
+    }),
+    networkNodeBytesTotalReceive: new DynamicProperty({
+      jsonKey: "network_node_bytes_total_receive",
+      provider: () => system.networkNodeBytesTotalReceive,
+      description: "Total amount of bytes received over the network",
+    }),
+    networkNodeBytesTotalTransmit: new DynamicProperty({
+      jsonKey: "network_node_bytes_total_transmit",
+      provider: () => system.networkNodeBytesTotalTransmit,
+      description: "Total amount of bytes transmitted over the network",
+    }),
+    miscNodeBootTsSeconds: new DynamicProperty({
+      jsonKey: "misc_node_boot_ts_seconds",
+      provider: () => system.miscNodeBootTsSeconds,
+      description: "Unix timestamp in seconds of boot time",
+    }),
+    miscOs: new DynamicProperty({
+      jsonKey: "misc_os",
+      provider: () => system.miscOs,
+      description: "Operating system, can be one of: lin, win, mac, unk for unknown",
+    }),
+  };
+}

package/src/monitoring/index.ts

@@ -0,0 +1,2 @@
+export * from "./options.js";
+export {MonitoringService} from "./service.js";

package/src/monitoring/options.ts

@@ -0,0 +1,19 @@
+export type MonitoringOptions = {
+  /** Remote endpoint URL where client stats are sent */
+  endpoint?: string;
+  /** Interval in milliseconds between sending client stats */
+  interval?: number;
+  /** Initial delay in milliseconds before client stats are sent */
+  initialDelay?: number;
+  /** Timeout in milliseconds for sending client stats */
+  requestTimeout?: number;
+  /** Enable collecting system stats */
+  collectSystemStats?: boolean;
+};
+
+export const defaultMonitoringOptions: Required<Omit<MonitoringOptions, "endpoint">> = {
+  interval: 60_000,
+  initialDelay: 30_000,
+  requestTimeout: 10_000,
+  collectSystemStats: true,
+};