use std::{fmt, sync::Arc, time::Duration};
use serde::Serialize;
pub(crate) use crate::module::quality::{Collector, SubscriptionInner};
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Serialize)]
#[non_exhaustive]
#[serde(rename_all = "snake_case")]
pub enum QualityMode {
#[default]
Off,
Basic,
Detailed,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize)]
#[non_exhaustive]
#[serde(rename_all = "snake_case")]
pub enum QualityProtocol {
Http,
WebSocket,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize)]
#[non_exhaustive]
#[serde(rename_all = "snake_case")]
pub enum QualityOperationKind {
HttpRequest,
HttpStream,
WsMessage,
WsRequest,
WsRequestOperation,
WsHeartbeat,
WsReceive,
Connection,
Heartbeat,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize)]
#[non_exhaustive]
#[serde(rename_all = "snake_case")]
pub enum PhaseKind {
Admission,
PermitWait,
QueueWait,
Published,
Dequeued,
WorkerStarted,
Preparation,
Provider,
RequestGetters,
RequestBuild,
Prepared,
ExecuteToHeaders,
ResponseHeaders,
FirstBodyChunk,
ResponseBody,
ReportFrozen,
ResponseQueue,
CallbackQueue,
Callback,
ResourcesReleased,
CompletionPublished,
DeliveryFinished,
ResultSelected,
Connector,
ConnectorPolled,
NetworkWait,
Backoff,
ConnectionAdmission,
Dns,
TcpConnect,
TcpCandidate,
ProxyTls,
ProxyConnect,
Tls,
WebSocketUpgrade,
SinkReadiness,
StartSend,
Flush,
Written,
ResponseWait,
ResponseMatched,
ManualDispatch,
ManualResolve,
Requeue,
Heartbeat,
PayloadReceived,
ResponseRouting,
HeartbeatObserved,
HeartbeatWriteStarted,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
#[non_exhaustive]
#[serde(rename_all = "snake_case")]
pub enum QualityOutcome {
Success,
Failed,
Cancelled,
Timeout,
Abandoned,
Unknown,
}
impl QualityOutcome {
pub fn from_error(error: &crate::api::error::NetError) -> Self {
use crate::api::error::ErrorKind;
match error.kind() {
ErrorKind::Cancelled => Self::Cancelled,
ErrorKind::TimedOut | ErrorKind::DeadlineExceeded => Self::Timeout,
_ => Self::Failed,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
#[non_exhaustive]
#[serde(rename_all = "snake_case")]
pub enum QualityDoctorState {
Dormant,
Running,
Failed,
Closed,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
pub struct QualityProtocols {
pub(crate) http: bool,
pub(crate) ws: bool,
}
impl QualityProtocols {
pub const fn new(http: bool, websocket: bool) -> Self {
Self {
http,
ws: websocket,
}
}
pub const fn http() -> Self {
Self::new(true, false)
}
pub const fn websocket() -> Self {
Self::new(false, true)
}
pub const fn none() -> Self {
Self::new(false, false)
}
pub const fn includes(self, protocol: QualityProtocol) -> bool {
match protocol {
QualityProtocol::Http => self.http,
QualityProtocol::WebSocket => self.ws,
}
}
}
impl Default for QualityProtocols {
fn default() -> Self {
Self::new(cfg!(feature = "http-client"), cfg!(feature = "ws-client"))
}
}
#[derive(Clone, Debug)]
pub struct QualityLimits {
pub(crate) ingress: usize,
pub(crate) active: usize,
pub(crate) history: usize,
pub(crate) phases: usize,
pub(crate) subscriptions: usize,
pub(crate) subscription_capacity: usize,
pub(crate) query_results: usize,
pub(crate) ttl: Duration,
pub(crate) window: Duration,
}
impl Default for QualityLimits {
fn default() -> Self {
Self {
ingress: 1024,
active: 256,
history: 256,
phases: 64,
subscriptions: 4,
subscription_capacity: 128,
query_results: 128,
ttl: Duration::from_secs(300),
window: Duration::from_secs(60),
}
}
}
impl QualityLimits {
pub fn with_ingress_capacity(mut self, value: usize) -> Self {
self.ingress = value;
self
}
pub fn with_active_capacity(mut self, value: usize) -> Self {
self.active = value;
self
}
pub fn with_history_capacity(mut self, value: usize) -> Self {
self.history = value;
self
}
pub fn with_max_phases(mut self, value: usize) -> Self {
self.phases = value;
self
}
pub fn with_max_subscriptions(mut self, value: usize) -> Self {
self.subscriptions = value;
self
}
pub fn with_subscription_capacity(mut self, value: usize) -> Self {
self.subscription_capacity = value;
self
}
pub fn with_max_query_results(mut self, value: usize) -> Self {
self.query_results = value;
self
}
pub fn with_retention(mut self, value: Duration) -> Self {
self.ttl = value;
self
}
pub fn with_window(mut self, value: Duration) -> Self {
self.window = value;
self
}
pub fn ingress_capacity(&self) -> usize {
self.ingress
}
pub fn active_capacity(&self) -> usize {
self.active
}
pub fn history_capacity(&self) -> usize {
self.history
}
pub fn max_phases(&self) -> usize {
self.phases
}
pub fn max_subscriptions(&self) -> usize {
self.subscriptions
}
pub fn subscription_capacity(&self) -> usize {
self.subscription_capacity
}
pub fn max_query_results(&self) -> usize {
self.query_results
}
pub fn retention(&self) -> Duration {
self.ttl
}
pub fn window(&self) -> Duration {
self.window
}
}
#[derive(Clone, Copy, Debug)]
pub struct QualitySampling {
pub(crate) operations: f64,
pub(crate) connections: f64,
}
impl Default for QualitySampling {
fn default() -> Self {
Self {
operations: 1.0,
connections: 1.0,
}
}
}
impl QualitySampling {
pub fn new(operation_detail_rate: f64, connection_detail_rate: f64) -> Self {
Self {
operations: operation_detail_rate,
connections: connection_detail_rate,
}
}
pub fn operation_detail_rate(&self) -> f64 {
self.operations
}
pub fn connection_detail_rate(&self) -> f64 {
self.connections
}
}
#[derive(Clone, Debug)]
pub struct QualityPolicy {
pub(crate) slow_phase: Duration,
pub(crate) failure_ratio: f64,
pub(crate) min_samples: usize,
}
impl Default for QualityPolicy {
fn default() -> Self {
Self {
slow_phase: Duration::from_millis(500),
failure_ratio: 0.2,
min_samples: 20,
}
}
}
impl QualityPolicy {
pub fn with_slow_phase_threshold(mut self, value: Duration) -> Self {
self.slow_phase = value;
self
}
pub fn with_failure_ratio_threshold(mut self, value: f64) -> Self {
self.failure_ratio = value;
self
}
pub fn with_min_samples(mut self, value: usize) -> Self {
self.min_samples = value;
self
}
pub fn slow_phase_threshold(&self) -> Duration {
self.slow_phase
}
pub fn failure_ratio_threshold(&self) -> f64 {
self.failure_ratio
}
pub fn min_samples(&self) -> usize {
self.min_samples
}
}
#[derive(Clone, Debug, Default)]
pub struct QualityDoctorConfig {
pub(crate) mode: QualityMode,
pub(crate) limits: QualityLimits,
pub(crate) sampling: QualitySampling,
pub(crate) protocols: QualityProtocols,
pub(crate) policy: QualityPolicy,
}
impl QualityDoctorConfig {
pub fn basic() -> Self {
Self {
mode: QualityMode::Basic,
..Self::default()
}
}
pub fn detailed() -> Self {
Self {
mode: QualityMode::Detailed,
..Self::default()
}
}
pub fn with_limits(mut self, value: QualityLimits) -> Self {
self.limits = value;
self
}
pub fn with_sampling(mut self, value: QualitySampling) -> Self {
self.sampling = value;
self
}
pub fn with_protocols(mut self, value: QualityProtocols) -> Self {
self.protocols = value;
self
}
pub fn with_policy(mut self, value: QualityPolicy) -> Self {
self.policy = value;
self
}
pub fn mode(&self) -> QualityMode {
self.mode
}
pub fn limits(&self) -> &QualityLimits {
&self.limits
}
pub fn sampling(&self) -> QualitySampling {
self.sampling
}
pub fn protocols(&self) -> QualityProtocols {
self.protocols
}
pub fn policy(&self) -> &QualityPolicy {
&self.policy
}
pub fn validate(&self) -> Result<(), QualityError> {
let limits = &self.limits;
for (name, value, max) in [
("ingress_capacity", limits.ingress, 65_536),
("active_capacity", limits.active, 4096),
("history_capacity", limits.history, 4096),
("max_phases", limits.phases, 512),
("max_subscriptions", limits.subscriptions, 64),
("subscription_capacity", limits.subscription_capacity, 4096),
("max_query_results", limits.query_results, 8192),
] {
if value == 0 || value > max {
return Err(QualityError::InvalidConfig(name));
}
}
if limits
.active
.saturating_add(limits.history)
.saturating_mul(limits.phases)
> 262_144
{
return Err(QualityError::InvalidConfig("report_phase_budget"));
}
if limits
.subscriptions
.saturating_mul(limits.subscription_capacity)
.saturating_mul(limits.phases)
> 262_144
{
return Err(QualityError::InvalidConfig("subscription_phase_budget"));
}
if limits.ttl.is_zero()
|| limits.window.is_zero()
|| limits.ttl > Duration::from_secs(86_400)
|| limits.window > limits.ttl
{
return Err(QualityError::InvalidConfig("retention/window"));
}
for rate in [
self.sampling.operations,
self.sampling.connections,
self.policy.failure_ratio,
] {
if !rate.is_finite() || !(0.0..=1.0).contains(&rate) {
return Err(QualityError::InvalidConfig("sampling/policy_ratio"));
}
}
if self.policy.slow_phase.is_zero()
|| self.policy.min_samples == 0
|| self.policy.min_samples > 8192
{
return Err(QualityError::InvalidConfig("policy_threshold"));
}
if (self.protocols.http && !cfg!(feature = "http-client"))
|| (self.protocols.ws && !cfg!(feature = "ws-client"))
{
return Err(QualityError::InvalidConfig("protocol_not_compiled"));
}
Ok(())
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum QualityError {
InvalidConfig(&'static str),
InvalidQuery(&'static str),
Capacity,
OwnerClosed,
CollectorFailed,
ExportFailed,
RuntimeUnavailable,
}
impl fmt::Display for QualityError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::InvalidConfig(field) => write!(f, "invalid quality configuration: {field}"),
Self::InvalidQuery(field) => write!(f, "invalid quality query: {field}"),
Self::Capacity => f.write_str("quality diagnostic capacity reached"),
Self::OwnerClosed => f.write_str("quality owner is closed"),
Self::CollectorFailed => f.write_str("quality collector is unavailable"),
Self::ExportFailed => f.write_str("quality JSON export failed"),
Self::RuntimeUnavailable => {
f.write_str("quality subscription requires an active Tokio time driver")
}
}
}
}
impl std::error::Error for QualityError {}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize)]
pub struct QualityReportRef {
pub(crate) scope: u64,
pub(crate) id: u64,
pub(crate) kind: QualityOperationKind,
pub(crate) detailed: bool,
}
impl QualityReportRef {
pub fn scope(&self) -> u64 {
self.scope
}
pub fn id(&self) -> u64 {
self.id
}
pub fn kind(&self) -> QualityOperationKind {
self.kind
}
pub fn detail_selected(&self) -> bool {
self.detailed
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
#[non_exhaustive]
#[serde(rename_all = "snake_case")]
pub enum QualityObservationState {
InProgress,
Completed,
Expired,
OwnerClosed,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
#[non_exhaustive]
#[serde(rename_all = "snake_case")]
pub enum QualityDetailState {
BasicMode,
Selected,
NotSampled,
}
#[derive(Clone, Debug, Serialize)]
pub struct QualityPhase {
pub(crate) instance_id: u64,
pub(crate) kind: PhaseKind,
pub(crate) start: Duration,
pub(crate) end: Option<Duration>,
pub(crate) associations: QualityAssociations,
}
impl QualityPhase {
pub fn instance_id(&self) -> u64 {
self.instance_id
}
pub fn kind(&self) -> PhaseKind {
self.kind
}
pub fn start_offset(&self) -> Duration {
self.start
}
pub fn end_offset(&self) -> Option<Duration> {
self.end
}
pub fn duration(&self) -> Option<Duration> {
self.end.map(|end| end.saturating_sub(self.start))
}
pub fn associations(&self) -> &QualityAssociations {
&self.associations
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
#[non_exhaustive]
#[serde(rename_all = "snake_case")]
pub enum QualityPhaseState {
Running,
Ended,
ReportCompleted,
ReportExpired,
OwnerClosed,
}
#[derive(Clone, Debug, Serialize)]
pub struct QualityPhaseActivity {
pub(crate) instance_id: u64,
pub(crate) kind: PhaseKind,
pub(crate) start: Duration,
pub(crate) end: Option<Duration>,
pub(crate) state: QualityPhaseState,
pub(crate) associations: QualityAssociations,
pub(crate) start_observed: bool,
}
impl QualityPhaseActivity {
pub fn instance_id(&self) -> u64 {
self.instance_id
}
pub fn kind(&self) -> PhaseKind {
self.kind
}
pub fn start_offset(&self) -> Duration {
self.start
}
pub fn end_offset(&self) -> Option<Duration> {
self.end
}
pub fn state(&self) -> QualityPhaseState {
self.state
}
pub fn associations(&self) -> &QualityAssociations {
&self.associations
}
pub fn start_observed(&self) -> bool {
self.start_observed
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
#[non_exhaustive]
#[serde(rename_all = "snake_case")]
pub enum QualityHttpVersion {
Http09,
Http10,
Http11,
Http2,
Http3,
Unknown,
}
#[derive(Clone, Debug, Default, Serialize)]
pub struct QualityAssociations {
pub(crate) attempt: Option<u64>,
pub(crate) hop: Option<u64>,
pub(crate) connection: Option<u64>,
pub(crate) session: Option<u64>,
pub(crate) cycle: Option<u64>,
pub(crate) operation: Option<u64>,
pub(crate) parent: Option<QualityReportRef>,
}
impl QualityAssociations {
pub fn attempt(&self) -> Option<u64> {
self.attempt
}
pub fn hop(&self) -> Option<u64> {
self.hop
}
pub fn connection(&self) -> Option<u64> {
self.connection
}
pub fn session(&self) -> Option<u64> {
self.session
}
pub fn cycle(&self) -> Option<u64> {
self.cycle
}
pub fn operation(&self) -> Option<u64> {
self.operation
}
pub fn parent(&self) -> Option<QualityReportRef> {
self.parent
}
}
#[derive(Clone, Debug, Serialize)]
pub struct QualityReport {
pub(crate) schema_version: u32,
pub(crate) reference: QualityReportRef,
pub(crate) protocol: QualityProtocol,
pub(crate) client_id: u64,
pub(crate) revision: u64,
pub(crate) started: Duration,
pub(crate) result_at: Option<Duration>,
pub(crate) finished: Option<Duration>,
pub(crate) outcome: Option<QualityOutcome>,
pub(crate) http_status: Option<u16>,
pub(crate) http_version: Option<QualityHttpVersion>,
#[serde(skip_serializing_if = "Option::is_none")]
pub(crate) heartbeat_schedule_delay: Option<Duration>,
pub(crate) failure: Option<QualityFailure>,
pub(crate) state: QualityObservationState,
pub(crate) detail: QualityDetailState,
pub(crate) phases: Vec<QualityPhase>,
pub(crate) phase_activity: Vec<QualityPhaseActivity>,
pub(crate) associations: QualityAssociations,
pub(crate) bytes: u64,
pub(crate) phase_overflow: u64,
pub(crate) possibly_incomplete: bool,
pub(crate) counters_saturated: bool,
}
impl QualityReport {
pub fn schema_version(&self) -> u32 {
self.schema_version
}
pub fn reference(&self) -> QualityReportRef {
self.reference
}
pub fn protocol(&self) -> QualityProtocol {
self.protocol
}
pub fn client_id(&self) -> u64 {
self.client_id
}
pub fn revision(&self) -> u64 {
self.revision
}
pub fn started_offset(&self) -> Duration {
self.started
}
pub fn result_offset(&self) -> Option<Duration> {
self.result_at
}
pub fn finished_offset(&self) -> Option<Duration> {
self.finished
}
pub fn duration(&self) -> Option<Duration> {
self.finished.map(|end| end.saturating_sub(self.started))
}
pub fn result_duration(&self) -> Option<Duration> {
self.result_at.map(|end| end.saturating_sub(self.started))
}
pub fn heartbeat_schedule_delay(&self) -> Option<Duration> {
self.heartbeat_schedule_delay
}
pub fn outcome(&self) -> Option<QualityOutcome> {
self.outcome
}
pub fn http_status(&self) -> Option<u16> {
self.http_status
}
pub fn http_version(&self) -> Option<QualityHttpVersion> {
self.http_version
}
pub fn failure(&self) -> Option<&QualityFailure> {
self.failure.as_ref()
}
pub fn state(&self) -> QualityObservationState {
self.state
}
pub fn detail_state(&self) -> QualityDetailState {
self.detail
}
pub fn phases(&self) -> &[QualityPhase] {
&self.phases
}
pub fn phase_activity(&self) -> &[QualityPhaseActivity] {
&self.phase_activity
}
pub fn active_phases(&self) -> impl Iterator<Item = &QualityPhaseActivity> {
self.phase_activity
.iter()
.filter(|phase| phase.state == QualityPhaseState::Running)
}
pub fn associations(&self) -> &QualityAssociations {
&self.associations
}
pub fn payload_bytes(&self) -> u64 {
self.bytes
}
pub fn dropped_phases(&self) -> u64 {
self.phase_overflow
}
pub fn possibly_incomplete(&self) -> bool {
self.possibly_incomplete
}
pub fn counters_saturated(&self) -> bool {
self.counters_saturated
}
pub fn to_json(&self) -> Result<String, QualityError> {
serde_json::to_string(self).map_err(|_| QualityError::ExportFailed)
}
}
pub type OperationReport = QualityReport;
pub type ConnectionReport = QualityReport;
#[derive(Clone, Copy, Debug, Serialize)]
pub struct QualityFailure {
#[serde(serialize_with = "serialize_error_kind")]
pub(crate) kind: crate::api::error::ErrorKind,
#[serde(serialize_with = "serialize_error_stage")]
pub(crate) stage: Option<crate::api::error::ErrorStage>,
}
impl QualityFailure {
pub fn kind(&self) -> crate::api::error::ErrorKind {
self.kind
}
pub fn stage(&self) -> Option<crate::api::error::ErrorStage> {
self.stage
}
}
fn serialize_error_kind<S: serde::Serializer>(
kind: &crate::api::error::ErrorKind,
serializer: S,
) -> Result<S::Ok, S::Error> {
use crate::api::error::ErrorKind::*;
serializer.serialize_str(match kind {
InvalidInput => "invalid_input",
InvalidConfig => "invalid_config",
Io => "io",
Dns => "dns",
Tls => "tls",
Protocol => "protocol",
HandshakeRejected => "handshake_rejected",
ProviderFailed => "provider_failed",
CallbackPanicked => "callback_panicked",
RuntimeUnavailable => "runtime_unavailable",
ResourceExhausted => "resource_exhausted",
QueueFull => "queue_full",
QueueClosed => "queue_closed",
ItemTooLarge => "item_too_large",
PendingLimitReached => "pending_limit_reached",
SubscriptionLimitReached => "subscription_limit_reached",
CallbackOverflow => "callback_overflow",
ControlOverflow => "control_overflow",
ObservationLagged => "observation_lagged",
NotConnected => "not_connected",
NotRunning => "not_running",
Unsupported => "unsupported",
SessionAlreadyExists => "session_already_exists",
ConnectionClosing => "connection_closing",
Closed => "closed",
EngineDropped => "engine_dropped",
Cancelled => "cancelled",
TimedOut => "timed_out",
DeadlineExceeded => "deadline_exceeded",
DeliveryUnknown => "delivery_unknown",
RetryExhausted => "retry_exhausted",
InvalidPolicy => "invalid_policy",
BodyNotReplayable => "body_not_replayable",
DuplicateRequestId => "duplicate_request_id",
RoutingDisabled => "routing_disabled",
RoutingModeMismatch => "routing_mode_mismatch",
ClientAlreadyExists => "client_already_exists",
ClientNotFound => "client_not_found",
Internal => "internal",
HttpStatus => "http_status",
})
}
fn serialize_error_stage<S: serde::Serializer>(
stage: &Option<crate::api::error::ErrorStage>,
serializer: S,
) -> Result<S::Ok, S::Error> {
use crate::api::error::ErrorStage::*;
let name = stage.map(|stage| match stage {
Configuration => "configuration",
Provider => "provider",
RequestBuild => "request_build",
Dns => "dns",
Tcp => "tcp",
Proxy => "proxy",
ProxyTls => "proxy_tls",
Tls => "tls",
Upgrade => "upgrade",
Admission => "admission",
Queue => "queue",
Write => "write",
Response => "response",
Receive => "receive",
Heartbeat => "heartbeat",
Close => "close",
Dispatch => "dispatch",
NetworkMonitor => "network_monitor",
Runtime => "runtime",
});
name.serialize(serializer)
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum QualityLookup {
Available(Arc<QualityReport>),
Evicted,
NotRetained {
owner_state: QualityDoctorState,
},
WrongScope,
}
#[derive(Clone, Debug, Default)]
pub struct QualityQuery {
pub(crate) protocol: Option<QualityProtocol>,
pub(crate) client_id: Option<u64>,
pub(crate) kind: Option<QualityOperationKind>,
pub(crate) window: Option<Duration>,
pub(crate) limit: Option<usize>,
}
impl QualityQuery {
pub fn with_protocol(mut self, value: QualityProtocol) -> Self {
self.protocol = Some(value);
self
}
pub fn with_client_id(mut self, value: u64) -> Self {
self.client_id = Some(value);
self
}
pub fn with_kind(mut self, value: QualityOperationKind) -> Self {
self.kind = Some(value);
self
}
pub fn with_window(mut self, value: Duration) -> Self {
self.window = Some(value);
self
}
pub fn with_limit(mut self, value: usize) -> Self {
self.limit = Some(value);
self
}
pub(crate) fn matches(&self, report: &QualityReport) -> bool {
self.protocol.is_none_or(|value| report.protocol == value)
&& self.client_id.is_none_or(|value| report.client_id == value)
&& self.kind.is_none_or(|value| report.reference.kind == value)
}
}
#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize)]
pub struct QualityCounters {
pub(crate) begin_attempted: u64,
pub(crate) begin_enqueued: u64,
pub(crate) records_observed: u64,
pub(crate) ingress_dropped: u64,
pub(crate) ingress_lock_contended_dropped: u64,
pub(crate) ingress_queue_full_dropped: u64,
pub(crate) ingress_closed_rejected: u64,
pub(crate) ingress_failed_rejected: u64,
pub(crate) ingress_high_watermark: u64,
pub(crate) drop_summaries_lost: u64,
pub(crate) orphan_events: u64,
pub(crate) records_evicted: u64,
pub(crate) records_expired: u64,
pub(crate) subscriber_dropped: u64,
pub(crate) id_exhausted: u64,
pub(crate) active_capacity_skipped: u64,
pub(crate) saturated: bool,
}
impl QualityCounters {
pub fn begin_attempted(&self) -> u64 {
self.begin_attempted
}
pub fn begin_enqueued(&self) -> u64 {
self.begin_enqueued
}
pub fn records_observed(&self) -> u64 {
self.records_observed
}
pub fn ingress_dropped(&self) -> u64 {
self.ingress_dropped
}
pub fn ingress_lock_contended_dropped(&self) -> u64 {
self.ingress_lock_contended_dropped
}
pub fn ingress_queue_full_dropped(&self) -> u64 {
self.ingress_queue_full_dropped
}
pub fn ingress_closed_rejected(&self) -> u64 {
self.ingress_closed_rejected
}
pub fn ingress_failed_rejected(&self) -> u64 {
self.ingress_failed_rejected
}
pub fn ingress_high_watermark(&self) -> u64 {
self.ingress_high_watermark
}
pub fn drop_summaries_lost(&self) -> u64 {
self.drop_summaries_lost
}
pub fn orphan_events(&self) -> u64 {
self.orphan_events
}
pub fn records_evicted(&self) -> u64 {
self.records_evicted
}
pub fn records_expired(&self) -> u64 {
self.records_expired
}
pub fn subscriber_dropped(&self) -> u64 {
self.subscriber_dropped
}
pub fn id_exhausted(&self) -> u64 {
self.id_exhausted
}
pub fn active_capacity_skipped(&self) -> u64 {
self.active_capacity_skipped
}
pub fn saturated(&self) -> bool {
self.saturated
}
}
#[derive(Clone, Debug, Default, Serialize)]
pub struct QualitySummary {
pub(crate) protocols: Vec<QualityProtocol>,
pub(crate) operation_kinds: Vec<QualityOperationKind>,
pub(crate) retained: u64,
pub(crate) completed: u64,
pub(crate) successes: u64,
pub(crate) failures: u64,
pub(crate) timeouts: u64,
pub(crate) cancelled: u64,
pub(crate) incomplete: u64,
pub(crate) latency_samples: u64,
pub(crate) p50: Option<Duration>,
pub(crate) p95: Option<Duration>,
pub(crate) p99: Option<Duration>,
}
impl QualitySummary {
pub fn protocols(&self) -> &[QualityProtocol] {
&self.protocols
}
pub fn mixed_protocols(&self) -> bool {
self.protocols.len() > 1
}
pub fn operation_kinds(&self) -> &[QualityOperationKind] {
&self.operation_kinds
}
pub fn mixed_kinds(&self) -> bool {
self.operation_kinds.len() > 1
}
pub fn retained(&self) -> u64 {
self.retained
}
pub fn completed(&self) -> u64 {
self.completed
}
pub fn successes(&self) -> u64 {
self.successes
}
pub fn failures(&self) -> u64 {
self.failures
}
pub fn timeouts(&self) -> u64 {
self.timeouts
}
pub fn cancelled(&self) -> u64 {
self.cancelled
}
pub fn incomplete(&self) -> u64 {
self.incomplete
}
pub fn latency_samples(&self) -> u64 {
self.latency_samples
}
pub fn p50(&self) -> Option<Duration> {
self.p50
}
pub fn p95(&self) -> Option<Duration> {
self.p95
}
pub fn p99(&self) -> Option<Duration> {
self.p99
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
#[non_exhaustive]
#[serde(rename_all = "snake_case")]
pub enum QualityFindingKind {
SlowObservedPhase,
HighObservedFailureRatio,
IncompleteCoverage,
}
#[derive(Clone, Debug, Serialize)]
pub struct QualityFinding {
pub(crate) kind: QualityFindingKind,
pub(crate) phase: Option<PhaseKind>,
pub(crate) reference: Option<QualityReportRef>,
pub(crate) samples: u64,
pub(crate) duration: Option<Duration>,
pub(crate) threshold: Option<Duration>,
}
impl QualityFinding {
pub fn kind(&self) -> QualityFindingKind {
self.kind
}
pub fn phase(&self) -> Option<PhaseKind> {
self.phase
}
pub fn reference(&self) -> Option<QualityReportRef> {
self.reference
}
pub fn samples(&self) -> u64 {
self.samples
}
pub fn observed_duration(&self) -> Option<Duration> {
self.duration
}
pub fn threshold(&self) -> Option<Duration> {
self.threshold
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
#[non_exhaustive]
#[serde(rename_all = "snake_case")]
pub enum QualityDropReason {
LockContended,
QueueFull,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
#[non_exhaustive]
#[serde(rename_all = "snake_case")]
pub enum QualityEventKind {
Begin,
PhaseStarted,
PhaseEnded,
Milestone,
Result,
Association,
Parent,
Finish,
HttpVersion,
HeartbeatScheduleDelay,
}
#[derive(Clone, Debug, Serialize)]
pub struct QualityDropSummary {
pub(crate) reference: QualityReportRef,
pub(crate) event_kind: QualityEventKind,
pub(crate) phase_kind: Option<PhaseKind>,
pub(crate) phase_instance_id: Option<u64>,
pub(crate) reason: QualityDropReason,
pub(crate) event_offset: Duration,
}
impl QualityDropSummary {
pub fn reference(&self) -> QualityReportRef {
self.reference
}
pub fn event_kind(&self) -> QualityEventKind {
self.event_kind
}
pub fn phase_kind(&self) -> Option<PhaseKind> {
self.phase_kind
}
pub fn phase_instance_id(&self) -> Option<u64> {
self.phase_instance_id
}
pub fn reason(&self) -> QualityDropReason {
self.reason
}
pub fn event_offset(&self) -> Duration {
self.event_offset
}
}
#[derive(Clone, Debug, Serialize)]
pub struct QualitySnapshot {
pub(crate) schema_version: u32,
pub(crate) revision: u64,
pub(crate) scope: u64,
pub(crate) captured_at: Duration,
pub(crate) window: Duration,
pub(crate) state: QualityDoctorState,
pub(crate) summary: QualitySummary,
pub(crate) counters: QualityCounters,
pub(crate) recent_drops: Vec<QualityDropSummary>,
pub(crate) reports: Vec<QualityReport>,
pub(crate) findings: Vec<QualityFinding>,
pub(crate) results_truncated: bool,
}
impl QualitySnapshot {
pub fn schema_version(&self) -> u32 {
self.schema_version
}
pub fn revision(&self) -> u64 {
self.revision
}
pub fn scope(&self) -> u64 {
self.scope
}
pub fn captured_at_offset(&self) -> Duration {
self.captured_at
}
pub fn window(&self) -> Duration {
self.window
}
pub fn state(&self) -> QualityDoctorState {
self.state
}
pub fn summary(&self) -> &QualitySummary {
&self.summary
}
pub fn counters(&self) -> &QualityCounters {
&self.counters
}
pub fn recent_drops(&self) -> &[QualityDropSummary] {
&self.recent_drops
}
pub fn reports(&self) -> &[QualityReport] {
&self.reports
}
pub fn findings(&self) -> &[QualityFinding] {
&self.findings
}
pub fn results_truncated(&self) -> bool {
self.results_truncated
}
pub fn to_json(&self) -> Result<String, QualityError> {
serde_json::to_string(self).map_err(|_| QualityError::ExportFailed)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
#[non_exhaustive]
#[serde(rename_all = "snake_case")]
pub enum QualityCapabilityLevel {
Supported,
Partial,
Unsupported,
DisabledByConfig,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
#[non_exhaustive]
#[serde(rename_all = "snake_case")]
pub enum QualityCapabilityReason {
SdkBoundary,
DependencyOpaque,
CompetingConnectionCandidates,
ConsumerDrivenBody,
ProtocolDisabled,
FeatureNotCompiled,
SystemResolutionAggregate,
NotPacketCapture,
ProtocolNotApplicable,
NotInstrumented,
DetailDisabled,
}
#[derive(Clone, Debug, Serialize)]
pub struct QualityCapability {
pub(crate) protocol: QualityProtocol,
pub(crate) phase: PhaseKind,
pub(crate) level: QualityCapabilityLevel,
pub(crate) reason: QualityCapabilityReason,
}
impl QualityCapability {
pub fn protocol(&self) -> QualityProtocol {
self.protocol
}
pub fn phase(&self) -> PhaseKind {
self.phase
}
pub fn level(&self) -> QualityCapabilityLevel {
self.level
}
pub fn reason(&self) -> QualityCapabilityReason {
self.reason
}
}
#[derive(Clone, Debug, Serialize)]
pub struct QualityCapabilities {
pub(crate) version: u32,
pub(crate) phases: Vec<QualityCapability>,
}
impl QualityCapabilities {
pub fn version(&self) -> u32 {
self.version
}
pub fn phases(&self) -> &[QualityCapability] {
&self.phases
}
pub fn exact_http_connection_identity(&self) -> bool {
false
}
pub fn packet_timing(&self) -> bool {
false
}
}
#[derive(Clone, Debug)]
pub struct QualitySubscriptionOptions {
pub(crate) capacity: usize,
pub(crate) query: QualityQuery,
pub(crate) snapshots: bool,
pub(crate) poll_interval: Duration,
}
impl Default for QualitySubscriptionOptions {
fn default() -> Self {
Self {
capacity: 64,
query: QualityQuery::default(),
snapshots: false,
poll_interval: Duration::from_millis(25),
}
}
}
impl QualitySubscriptionOptions {
pub fn with_capacity(mut self, value: usize) -> Self {
self.capacity = value;
self
}
pub fn with_filter(mut self, value: QualityQuery) -> Self {
self.query = value;
self
}
pub fn with_snapshot_updates(mut self, value: bool) -> Self {
self.snapshots = value;
self
}
pub fn with_poll_interval(mut self, value: Duration) -> Self {
self.poll_interval = value;
self
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
#[non_exhaustive]
#[serde(rename_all = "snake_case")]
pub enum QualityGapScope {
Ingress,
Subscription,
}
#[derive(Clone, Debug, Serialize)]
pub struct QualityGap {
pub(crate) scope: QualityGapScope,
pub(crate) dropped: u64,
}
impl QualityGap {
pub fn scope(&self) -> QualityGapScope {
self.scope
}
pub fn dropped(&self) -> u64 {
self.dropped
}
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum QualityUpdate {
ReportUpdated(Arc<QualityReport>),
ReportCompleted(Arc<QualityReport>),
SnapshotUpdated(Arc<QualitySnapshot>),
Gap(QualityGap),
Closed,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum QualityTryRecvError {
Empty,
Closed,
}
#[derive(Clone)]
pub struct QualityDoctor {
pub(crate) inner: Arc<Collector>,
}
impl fmt::Debug for QualityDoctor {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("QualityDoctor")
.field("state", &self.state())
.finish_non_exhaustive()
}
}
pub struct QualitySubscription {
pub(crate) inner: SubscriptionInner,
}
impl fmt::Debug for QualitySubscription {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("QualitySubscription")
.finish_non_exhaustive()
}
}