use crate::network::{TransportKind, TransportMode};
use std::{fmt, sync::Arc, time::Duration};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Operation {
Upload,
Download,
UploadPart,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Outcome {
Success,
Error,
Cancelled,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct DiagnosticRange {
pub offset: i64,
pub length: i64,
}
#[derive(Clone, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub struct TransferDiagnostics {
pub working_time: Duration,
pub requested_range: Option<DiagnosticRange>,
pub resolved_range: Option<DiagnosticRange>,
pub object_size: Option<u64>,
pub satellite: String,
pub os: &'static str,
pub architecture: &'static str,
pub cpu_count: Option<usize>,
pub expires: Option<bool>,
pub error_kind: Option<String>,
pub retryable: Option<bool>,
}
impl Default for TransferDiagnostics {
fn default() -> Self {
Self {
working_time: Duration::ZERO,
requested_range: None,
resolved_range: None,
object_size: None,
satellite: String::new(),
os: std::env::consts::OS,
architecture: std::env::consts::ARCH,
cpu_count: None,
expires: None,
error_kind: None,
retryable: None,
}
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum TelemetryEvent {
Connection {
transport: TransportKind,
elapsed: Duration,
outcome: Outcome,
},
Transfer {
operation: Operation,
bytes: u64,
elapsed: Duration,
first_byte: Option<Duration>,
outcome: Outcome,
transport_mode: TransportMode,
diagnostics: Box<TransferDiagnostics>,
},
}
#[derive(Clone)]
pub struct Telemetry(Arc<dyn Fn(TelemetryEvent) + Send + Sync>);
impl Telemetry {
pub fn new(callback: impl Fn(TelemetryEvent) + Send + Sync + 'static) -> Self {
Self(Arc::new(callback))
}
pub fn emit(&self, event: TelemetryEvent) {
let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| (self.0)(event)));
}
}
impl fmt::Debug for Telemetry {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("Telemetry(..)")
}
}
impl PartialEq for Telemetry {
fn eq(&self, other: &Self) -> bool {
Arc::ptr_eq(&self.0, &other.0)
}
}
impl Eq for Telemetry {}
impl Telemetry {
pub(crate) fn to_rpc(&self) -> storj_rpc::telemetry::Telemetry {
let observer = self.clone();
storj_rpc::telemetry::Telemetry::new(move |event| {
use storj_rpc::{telemetry as rpc, transport::TransportKind as Kind};
if let rpc::TelemetryEvent::Connection {
transport,
elapsed,
outcome,
} = event
{
observer.emit(TelemetryEvent::Connection {
transport: match transport {
Kind::Tcp => TransportKind::Tcp,
Kind::Quic => TransportKind::Quic,
Kind::Noise => TransportKind::Noise,
},
elapsed,
outcome: match outcome {
rpc::Outcome::Success => Outcome::Success,
rpc::Outcome::Error => Outcome::Error,
rpc::Outcome::Cancelled => Outcome::Cancelled,
},
});
}
})
}
}