Struct NodeConfig 

pub struct NodeConfig {
    pub tick_interval: Duration,
    pub max_packet_buffer: usize,
    pub max_outgoing_buffer: usize,
    pub max_local_events: usize,
    pub metrics: Option<NodeMetrics>,
    pub observability: Option<ObservabilityConfig>,
    pub health_checks: Option<HealthCheckConfig>,
}

ELARA Node configuration

Observability

The observability field provides unified configuration for all observability components (logging, tracing, metrics). It is optional and disabled by default.

When enabled, observability components are initialized before the node starts:

• Logging: Structured logs with configurable format and output
• Tracing: Distributed tracing with OpenTelemetry support
• Metrics Server: HTTP server exposing Prometheus metrics

Example with Observability

use elara_runtime::node::NodeConfig;
use elara_runtime::observability::{
    ObservabilityConfig, LoggingConfig, LogLevel, LogFormat, LogOutput,
    MetricsServerConfig
};
use std::time::Duration;

let config = NodeConfig {
    tick_interval: Duration::from_millis(100),
    max_packet_buffer: 1000,
    max_outgoing_buffer: 1000,
    max_local_events: 1000,
    metrics: None,
    observability: Some(ObservabilityConfig {
        logging: Some(LoggingConfig {
            level: LogLevel::Info,
            format: LogFormat::Json,
            output: LogOutput::Stdout,
        }),
        tracing: None,
        metrics_server: Some(MetricsServerConfig {
            bind_address: "0.0.0.0".to_string(),
            port: 9090,
        }),
    }),
};

Example without Observability (Default)

use elara_runtime::node::NodeConfig;
use std::time::Duration;

let config = NodeConfig {
    tick_interval: Duration::from_millis(100),
    max_packet_buffer: 1000,
    max_outgoing_buffer: 1000,
    max_local_events: 1000,
    metrics: None,
    observability: None, // Observability disabled
};

Fields

tick_interval: Duration

Tick interval

max_packet_buffer: usize

Maximum incoming packet buffer

max_outgoing_buffer: usize

Maximum outgoing packet buffer

max_local_events: usize

metrics: Option<NodeMetrics>

Optional metrics for monitoring (None = metrics disabled)

observability: Option<ObservabilityConfig>

Optional unified observability configuration (None = observability disabled)

When set, this enables structured logging, distributed tracing, and/or metrics server based on the provided configuration. All components are opt-in - set individual fields to None to disable specific components.

Note: This is separate from the metrics field. The metrics field provides direct access to metrics for the node runtime, while observability provides a unified initialization system with HTTP server support.

health_checks: Option<HealthCheckConfig>

Optional health check configuration (None = health checks disabled)

When set, this enables the health check system with built-in checks for:

• Connection health (minimum active connections)
• Memory usage (maximum memory threshold)
• Time drift (maximum drift from network consensus)
• State divergence (maximum pending events)

Health checks are opt-in and disabled by default. When enabled, you can configure thresholds for each check and optionally expose HTTP endpoints for Kubernetes probes and load balancers.

Example

use elara_runtime::node::NodeConfig;
use elara_runtime::health::HealthCheckConfig;
use std::time::Duration;

let config = NodeConfig {
    health_checks: Some(HealthCheckConfig::medium_deployment()),
    ..Default::default()
};

Production Deployment

Use the preset configurations for common deployment sizes:

• HealthCheckConfig::small_deployment() - 10 nodes
• HealthCheckConfig::medium_deployment() - 100 nodes
• HealthCheckConfig::large_deployment() - 1000 nodes

Or customize thresholds based on your specific requirements:

use elara_runtime::health::HealthCheckConfig;
use std::time::Duration;

let health_config = HealthCheckConfig {
    enabled: true,
    server_bind_address: Some("0.0.0.0:8080".parse().unwrap()),
    cache_ttl: Duration::from_secs(30),
    min_connections: Some(5),
    max_memory_mb: Some(2000),
    max_time_drift_ms: Some(100),
    max_pending_events: Some(1000),
};

Implementations

impl NodeConfig

pub fn init_health_checks( &self, node: Arc<Node>, ) -> Option<(Arc<HealthChecker>, Option<JoinHandle<Result<(), Error>>>)>

Initializes health checks based on the configuration.

This method creates a HealthChecker with the configured checks and optionally starts an HTTP server to expose health endpoints.

Arguments

• node - Arc reference to the Node for health checks that need node access

Returns

Returns Some((checker, server_handle)) if health checks are enabled, where:

• checker is the configured HealthChecker
• server_handle is Some(JoinHandle) if HTTP server is started, None otherwise

Returns None if health checks are disabled.

Example

use elara_runtime::node::{Node, NodeConfig};
use elara_runtime::health::HealthCheckConfig;
use std::sync::Arc;

let config = NodeConfig {
    health_checks: Some(HealthCheckConfig::medium_deployment()),
    ..Default::default()
};

let node = Arc::new(Node::with_config(config.clone()));

if let Some((checker, server_handle)) = config.init_health_checks(node) {
    println!("Health checks initialized");
     
    // Check health programmatically
    let status = checker.check_health();
    println!("Health status: {:?}", status.overall);
     
    // Server is running in background (if configured)
    if let Some(handle) = server_handle {
        // Server will run until handle is dropped or joined
    }
}

HTTP Endpoints

When server_bind_address is configured, the following endpoints are exposed:

• GET /health - Overall health status

  • Returns 200 OK if healthy or degraded
  • Returns 503 Service Unavailable if unhealthy

• GET /ready - Readiness probe (Kubernetes)

  • Returns 200 OK if healthy or degraded
  • Returns 503 Service Unavailable if unhealthy

• GET /live - Liveness probe (Kubernetes)

  • Returns 200 OK if healthy or degraded
  • Returns 503 Service Unavailable if unhealthy

Panics

Panics if the health check configuration is invalid (fails validation).

Trait Implementations

impl Clone for NodeConfig

fn clone(&self) -> NodeConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NodeConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for NodeConfig

fn default() -> Self

Returns the “default value” for a type.