Struct HealthMonitorBuilder 

pub struct HealthMonitorBuilder<T: HealthReportSender> { /* private fields */ }

Builder for creating a HealthMonitor instance.

Allows configuring optional parameters with sensible defaults. Required parameters must be set before calling [build()].

Examples

use std::convert::Infallible;
use tokio::sync::broadcast;
use bloop_server_framework::health_monitor::{
    HealthMonitorBuilder,
    HealthReport,
    HealthReportSender
};

struct DummySender;

impl HealthReportSender for DummySender {
    type Error = Infallible;

    async fn send(
        &mut self,
        report: &HealthReport,
        silent: bool
    ) -> Result<(), Self::Error> {
         Ok(())
    }
}

let (_, event_rx) = broadcast::channel(512);

let monitor = HealthMonitorBuilder::new()
    .sender(DummySender)
    .event_rx(event_rx)
    .max_client_events(100)
    .build()
    .expect("failed to build HealthMonitor");

Implementations

impl<T: HealthReportSender> HealthMonitorBuilder<T>

pub fn new() -> Self

Creates a new HealthMonitorBuilder with default configuration values.

You must provide at least a sender and an event receiver before calling [build()].

pub fn sender(self, sender: T) -> Self

Sets the report sender implementation.

This is a required field. The sender is used to transmit health reports during monitoring.

pub fn event_rx(self, event_rx: Receiver<Event>) -> Self

Sets the event receiver used to receive client health-related events.

This is a required field. The monitor listens to this channel for incoming events.

pub fn client_ids(self, client_ids: HashSet<String>) -> Self

Sets the initial list of known client IDs to track in the health report.

Defaults to an empty set if not provided.

pub fn max_client_events(self, max_client_events: usize) -> Self

Sets the maximum number of recent events to store per client.

Defaults to 50. Events beyond this limit are discarded (oldest first).

pub fn connection_loss_limit(self, connection_loss_limit: usize) -> Self

Sets the number of recent ConnectionLoss events required to consider a client unstable.

Defaults to 3.

pub fn check_interval(self, check_interval: Duration) -> Self

Sets how frequently the system checks for health status updates.

Defaults to 30 seconds.

pub fn reminder_interval(self, reminder_interval: Duration) -> Self

Sets the interval for sending health reminders if unhealthy clients are still present.

Defaults to 30 minutes.

pub fn offline_grace_period(self, offline_grace_period: Duration) -> Self

Sets the grace period after the last connection loss before a client is considered offline.

Defaults to 2 minutes.

pub fn connection_loss_window(self, connection_loss_window: Duration) -> Self

Sets the window of time used to count recent connection loss events.

Defaults to 10 minutes.

pub fn recovery_grace_period(self, recovery_grace_period: Duration) -> Self

Sets the duration a client must remain stable before being promoted to healthy.

Defaults to 20 minutes.

pub fn build(self) -> Result<HealthMonitor<T>, BuilderError>

Builds a HealthMonitor instance using the configured values.

Returns an error if required fields like the sender or event receiver are missing.

Trait Implementations

impl<T: Debug + HealthReportSender> Debug for HealthMonitorBuilder<T>

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

Formats the value using the given formatter.

impl<T: Default + HealthReportSender> Default for HealthMonitorBuilder<T>

fn default() -> HealthMonitorBuilder<T>

Returns the “default value” for a type.