shard-core 2.2.1

use serde::Serialize;
use std::sync::atomic::{AtomicU64, Ordering};

pub static METRICS: Metrics = Metrics::new();

pub struct Metrics {
    pub ops_init: AtomicU64,
    pub ops_add: AtomicU64,
    pub ops_commit: AtomicU64,
    pub ops_verify: AtomicU64,
    pub ops_checkout: AtomicU64,
    pub ops_push: AtomicU64,
    pub ops_pull: AtomicU64,
    pub ops_share: AtomicU64,
    pub ops_sync: AtomicU64,
    pub ops_prune: AtomicU64,
    pub ops_health: AtomicU64,
    pub ops_merge: AtomicU64,
    pub ops_log: AtomicU64,
    pub ops_status: AtomicU64,
    pub ops_diff: AtomicU64,
    pub ops_config: AtomicU64,
    pub ops_tag: AtomicU64,
    pub ops_export: AtomicU64,
    pub ops_import: AtomicU64,
    pub ops_backup: AtomicU64,
    pub ops_restore: AtomicU64,
    pub ops_recover: AtomicU64,
    pub ops_key_rotate: AtomicU64,
    pub ops_key_list: AtomicU64,
    pub ops_key_verify: AtomicU64,
    pub ops_peer_add: AtomicU64,
    pub ops_transfer_list: AtomicU64,
    pub ops_transfer_remove: AtomicU64,
    pub ops_relay: AtomicU64,
    pub errors_total: AtomicU64,
    pub chunks_written: AtomicU64,
    pub bytes_written: AtomicU64,
}

impl Default for Metrics {
    fn default() -> Self {
        Self::new()
    }
}

impl Metrics {
    pub const fn new() -> Self {
        Metrics {
            ops_init: AtomicU64::new(0),
            ops_add: AtomicU64::new(0),
            ops_commit: AtomicU64::new(0),
            ops_verify: AtomicU64::new(0),
            ops_checkout: AtomicU64::new(0),
            ops_push: AtomicU64::new(0),
            ops_pull: AtomicU64::new(0),
            ops_share: AtomicU64::new(0),
            ops_sync: AtomicU64::new(0),
            ops_prune: AtomicU64::new(0),
            ops_health: AtomicU64::new(0),
            ops_merge: AtomicU64::new(0),
            ops_log: AtomicU64::new(0),
            ops_status: AtomicU64::new(0),
            ops_diff: AtomicU64::new(0),
            ops_config: AtomicU64::new(0),
            ops_tag: AtomicU64::new(0),
            ops_export: AtomicU64::new(0),
            ops_import: AtomicU64::new(0),
            ops_backup: AtomicU64::new(0),
            ops_restore: AtomicU64::new(0),
            ops_recover: AtomicU64::new(0),
            ops_key_rotate: AtomicU64::new(0),
            ops_key_list: AtomicU64::new(0),
            ops_key_verify: AtomicU64::new(0),
            ops_peer_add: AtomicU64::new(0),
            ops_transfer_list: AtomicU64::new(0),
            ops_transfer_remove: AtomicU64::new(0),
            ops_relay: AtomicU64::new(0),
            errors_total: AtomicU64::new(0),
            chunks_written: AtomicU64::new(0),
            bytes_written: AtomicU64::new(0),
        }
    }

    pub fn snapshot(&self) -> MetricsSnapshot {
        MetricsSnapshot {
            ops_init: self.ops_init.load(Ordering::Relaxed),
            ops_add: self.ops_add.load(Ordering::Relaxed),
            ops_commit: self.ops_commit.load(Ordering::Relaxed),
            ops_verify: self.ops_verify.load(Ordering::Relaxed),
            ops_checkout: self.ops_checkout.load(Ordering::Relaxed),
            ops_push: self.ops_push.load(Ordering::Relaxed),
            ops_pull: self.ops_pull.load(Ordering::Relaxed),
            ops_share: self.ops_share.load(Ordering::Relaxed),
            ops_sync: self.ops_sync.load(Ordering::Relaxed),
            ops_prune: self.ops_prune.load(Ordering::Relaxed),
            ops_health: self.ops_health.load(Ordering::Relaxed),
            ops_merge: self.ops_merge.load(Ordering::Relaxed),
            ops_log: self.ops_log.load(Ordering::Relaxed),
            ops_status: self.ops_status.load(Ordering::Relaxed),
            ops_diff: self.ops_diff.load(Ordering::Relaxed),
            ops_config: self.ops_config.load(Ordering::Relaxed),
            ops_tag: self.ops_tag.load(Ordering::Relaxed),
            ops_export: self.ops_export.load(Ordering::Relaxed),
            ops_import: self.ops_import.load(Ordering::Relaxed),
            ops_backup: self.ops_backup.load(Ordering::Relaxed),
            ops_restore: self.ops_restore.load(Ordering::Relaxed),
            ops_recover: self.ops_recover.load(Ordering::Relaxed),
            ops_key_rotate: self.ops_key_rotate.load(Ordering::Relaxed),
            ops_key_list: self.ops_key_list.load(Ordering::Relaxed),
            ops_key_verify: self.ops_key_verify.load(Ordering::Relaxed),
            ops_peer_add: self.ops_peer_add.load(Ordering::Relaxed),
            ops_transfer_list: self.ops_transfer_list.load(Ordering::Relaxed),
            ops_transfer_remove: self.ops_transfer_remove.load(Ordering::Relaxed),
            ops_relay: self.ops_relay.load(Ordering::Relaxed),
            errors_total: self.errors_total.load(Ordering::Relaxed),
            chunks_written: self.chunks_written.load(Ordering::Relaxed),
            bytes_written: self.bytes_written.load(Ordering::Relaxed),
        }
    }
}

#[derive(Serialize)]
pub struct MetricsSnapshot {
    pub ops_init: u64,
    pub ops_add: u64,
    pub ops_commit: u64,
    pub ops_verify: u64,
    pub ops_checkout: u64,
    pub ops_push: u64,
    pub ops_pull: u64,
    pub ops_share: u64,
    pub ops_sync: u64,
    pub ops_prune: u64,
    pub ops_health: u64,
    pub ops_merge: u64,
    pub ops_log: u64,
    pub ops_status: u64,
    pub ops_diff: u64,
    pub ops_config: u64,
    pub ops_tag: u64,
    pub ops_export: u64,
    pub ops_import: u64,
    pub ops_backup: u64,
    pub ops_restore: u64,
    pub ops_recover: u64,
    pub ops_key_rotate: u64,
    pub ops_key_list: u64,
    pub ops_key_verify: u64,
    pub ops_peer_add: u64,
    pub ops_transfer_list: u64,
    pub ops_transfer_remove: u64,
    pub ops_relay: u64,
    pub errors_total: u64,
    pub chunks_written: u64,
    pub bytes_written: u64,
}