@lodestar/beacon-node 1.35.0-dev.fcf8d024ea → 1.35.0-dev.feed916580

package/src/metrics/metrics.ts

@@ -1,43 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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

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

package/src/metrics/utils/avgMinMax.ts

@@ -1,87 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,297 +0,0 @@
-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

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

package/src/monitoring/options.ts

@@ -1,19 +0,0 @@
-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,
-};