Struct Heartbeat

pub struct Heartbeat {
    start_time: Instant,
    last_heartbeat: Mutex<Instant>,
    total_success_circuits: AtomicU64,
    total_failed_circuits: AtomicU64,
    success_circuits_since_last: AtomicU64,
    failed_circuits_since_last: AtomicU64,
    relays_processed: AtomicU64,
    interval_secs: u64,
    report_on_consensus: bool,
    metrics_receiver: Mutex<Option<UnboundedReceiver<MetricEvent>>>,
}

Heartbeat structure for tracking and reporting scanner metrics

Fields

start_time: Instant

Time when the scanner started

last_heartbeat: Mutex<Instant>

Last time a heartbeat report was generated

total_success_circuits: AtomicU64

Total number of successful circuits created

total_failed_circuits: AtomicU64

Total number of failed circuits

success_circuits_since_last: AtomicU64

Successful circuits since last heartbeat

failed_circuits_since_last: AtomicU64

Failed circuits since last heartbeat

relays_processed: AtomicU64

Number of relays processed

interval_secs: u64

Interval between heartbeat reports in seconds

report_on_consensus: bool

Whether to report on new consensus events

metrics_receiver: Mutex<Option<UnboundedReceiver<MetricEvent>>>

Receiver for metric events

Implementations

impl Heartbeat

pub fn with_config(interval_secs: u64, report_on_consensus: bool) -> Arc<Self>

Create a new Heartbeat instance with custom configuration

pub fn create_metrics_collector( self: &Arc<Self>, ) -> UnboundedSender<MetricEvent>

Create a metrics collector for tracking circuit creation and relay events

async fn process_metrics(self: Arc<Self>)

Process incoming metrics events

pub fn process_completed_work(&self, completed_work: &CompletedWork)

Process a completed work and update the appropriate metrics

pub fn record_success_circuit(&self)

Increment counters for successful circuit

pub fn record_failed_circuit(&self)

Increment counters for failed circuit

pub fn set_relays_processed(&self, count: u64)

Set the number of relays processed

pub async fn start(self: Arc<Self>)

Start the heartbeat reporting task

async fn generate_report(&self)

Generate and log the heartbeat report

pub fn report_new_consensus(&self, relay_count: u64)

Generate a special report when a new consensus is received