use core::fmt;
use crate::driver::owner::observation::{
DriverObservationAdmissionError, DriverObservationAdmissionErrorKind, DriverObservationError,
DriverObservationErrorKind,
};
use crate::producer::ingress::ProducerShardLockError;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum EngineMetricsAdmissionErrorKind {
Capacity,
Closed,
HostUnavailable,
}
#[derive(Debug)]
pub struct EngineMetricsAdmissionError {
kind: EngineMetricsAdmissionErrorKind,
source: EngineMetricsAdmissionSource,
}
impl EngineMetricsAdmissionError {
pub(crate) const fn from_driver(source: DriverObservationAdmissionError) -> Self {
let kind = match source.kind() {
DriverObservationAdmissionErrorKind::Capacity => {
EngineMetricsAdmissionErrorKind::Capacity
}
DriverObservationAdmissionErrorKind::Closed => EngineMetricsAdmissionErrorKind::Closed,
DriverObservationAdmissionErrorKind::HostUnavailable => {
EngineMetricsAdmissionErrorKind::HostUnavailable
}
};
Self {
kind,
source: EngineMetricsAdmissionSource::Driver(source),
}
}
pub(crate) const fn from_producer(source: ProducerShardLockError) -> Self {
let (kind, source) = match source {
ProducerShardLockError::Contended => (
EngineMetricsAdmissionErrorKind::Capacity,
EngineMetricsAdmissionSource::ProducerContended,
),
ProducerShardLockError::Poisoned => (
EngineMetricsAdmissionErrorKind::HostUnavailable,
EngineMetricsAdmissionSource::ProducerUnavailable,
),
};
Self { kind, source }
}
pub const fn kind(&self) -> EngineMetricsAdmissionErrorKind {
self.kind
}
}
impl fmt::Display for EngineMetricsAdmissionError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "metrics admission failed: {}", self.source)
}
}
impl std::error::Error for EngineMetricsAdmissionError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match &self.source {
EngineMetricsAdmissionSource::Driver(source) => Some(source),
EngineMetricsAdmissionSource::ProducerContended
| EngineMetricsAdmissionSource::ProducerUnavailable => None,
}
}
}
#[derive(Debug)]
enum EngineMetricsAdmissionSource {
Driver(DriverObservationAdmissionError),
ProducerContended,
ProducerUnavailable,
}
impl fmt::Display for EngineMetricsAdmissionSource {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Driver(source) => source.fmt(formatter),
Self::ProducerContended => {
formatter.write_str("producer metrics ownership is temporarily contended")
}
Self::ProducerUnavailable => {
formatter.write_str("producer metrics ownership is unavailable")
}
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum EngineMetricsObserverErrorKind {
Draining,
Completion,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct EngineMetricsObserverError {
kind: EngineMetricsObserverErrorKind,
}
impl EngineMetricsObserverError {
pub(crate) const fn from_driver(source: DriverObservationError) -> Self {
let kind = match source.kind() {
DriverObservationErrorKind::Draining => EngineMetricsObserverErrorKind::Draining,
DriverObservationErrorKind::Completion => EngineMetricsObserverErrorKind::Completion,
};
Self { kind }
}
pub const fn kind(self) -> EngineMetricsObserverErrorKind {
self.kind
}
}
impl fmt::Display for EngineMetricsObserverError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self.kind {
EngineMetricsObserverErrorKind::Draining => {
formatter.write_str("the client began draining before metrics were captured")
}
EngineMetricsObserverErrorKind::Completion => {
formatter.write_str("the metrics completion owner became unavailable")
}
}
}
}
impl std::error::Error for EngineMetricsObserverError {}