Trait CustomMetricValue 

pub trait CustomMetricValue:
    Display
    + Debug
    + Send
    + Sync {
    // Required methods
    fn new_empty(&self) -> Arc<dyn CustomMetricValue> ;
    fn aggregate(&self, other: Arc<dyn CustomMetricValue + 'static>);
    fn as_any(&self) -> &dyn Any;
    fn is_eq(&self, other: &Arc<dyn CustomMetricValue>) -> bool;

    // Provided method
    fn as_usize(&self) -> usize { ... }
}

A trait for implementing custom metric values.

This trait enables defining application- or operator-specific metric types that can be aggregated and displayed alongside standard metrics. These custom metrics integrate with MetricValue::Custom and support aggregation logic, introspection, and optional numeric representation.

Requirements

Implementations of CustomMetricValue must satisfy the following:

1. Self::aggregate: Defines how two metric values are combined
2. Self::new_empty: Returns a new, zero-value instance for accumulation
3. Self::as_any: Enables dynamic downcasting for type-specific operations
4. Self::as_usize: Optionally maps the value to a usize (for sorting, display, etc.)
5. Self::is_eq: Implements comparison between two values, this isn’t reusing the std PartialEq trait because this trait is used dynamically in the context of MetricValue::Custom

Examples

#[derive(Debug, Default)]
struct MyCounter {
    count: AtomicUsize,
}

impl Display for MyCounter {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "count: {}", self.count.load(Ordering::Relaxed))
    }
}

impl CustomMetricValue for MyCounter {
    fn new_empty(&self) -> Arc<dyn CustomMetricValue> {
        Arc::new(Self::default())
    }

    fn aggregate(&self, other: Arc<dyn CustomMetricValue>) {
        let other = other.as_any().downcast_ref::<Self>().unwrap();
        self.count
            .fetch_add(other.count.load(Ordering::Relaxed), Ordering::Relaxed);
    }

    fn as_any(&self) -> &dyn Any {
        self
    }

    fn as_usize(&self) -> usize {
        self.count.load(Ordering::Relaxed)
    }

    fn is_eq(&self, other: &Arc<dyn CustomMetricValue>) -> bool {
        let Some(other) = other.as_any().downcast_ref::<Self>() else {
            return false;
        };

        self.count.load(Ordering::Relaxed) == other.count.load(Ordering::Relaxed)
    }
}

Required Methods

fn new_empty(&self) -> Arc<dyn CustomMetricValue>

Returns a new, zero-initialized version of this metric value.

This value is used during metric aggregation to accumulate results.

fn aggregate(&self, other: Arc<dyn CustomMetricValue + 'static>)

Merges another metric value into this one.

The type of other could be of a different custom type as long as it’s aggregatable into self.

fn as_any(&self) -> &dyn Any

Returns this value as a Any to support dynamic downcasting.

fn is_eq(&self, other: &Arc<dyn CustomMetricValue>) -> bool

Compares this value with another custom value.

Provided Methods

fn as_usize(&self) -> usize

Optionally returns a numeric representation of the value, if meaningful. Otherwise will default to zero.

This is used for sorting and summarizing metrics.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors