Introduce encoding::Number type

The different types of numbers in the prometheus ecosystem is limited
to signed & unsigned integers and double values. We can thus represent
those as an enum and delete a fair bit of code.

Author: thomaseizinger

examples/custom-metric.rs

@@ -1,4 +1,4 @@
-use prometheus_client::encoding::{text::encode, EncodeMetric, MetricEncoder};
+use prometheus_client::encoding::{text::encode, EncodeMetric, MetricEncoder, Number};
 use prometheus_client::metrics::MetricType;
 use prometheus_client::registry::Registry;
 
@@ -21,7 +21,7 @@ impl EncodeMetric for MyCustomMetric {
         // the Prometheus server.
 
         // TODO: Ideally the type hints would not be needed.
-        encoder.encode_counter::<(), u64>(rand::random::<u64>(), None)
+        encoder.encode_counter::<()>(Number::UnsignedInteger(rand::random::<u64>()), None)
     }
 
     fn metric_type(&self) -> prometheus_client::metrics::MetricType {

src/encoding.rs

@@ -77,15 +77,15 @@ macro_rules! for_both {
 }
 
 impl<'a> MetricEncoder<'a> {
-    pub fn encode_counter<S: EncodeLabelSet, V: EncodeExemplarValue>(
+    pub fn encode_counter<S: EncodeLabelSet>(
         &mut self,
-        v: impl EncodeCounterValue,
-        exemplar: Option<&Exemplar<S, V>>,
+        v: Number,
+        exemplar: Option<&Exemplar<S>>,
     ) -> Result<(), std::fmt::Error> {
         for_both!(self, e, e.encode_counter(v, exemplar))
     }
 
-    pub fn encode_gauge(&mut self, v: impl EncodeGaugeValue) -> Result<(), std::fmt::Error> {
+    pub fn encode_gauge(&mut self, v: Number) -> Result<(), std::fmt::Error> {
         for_both!(self, e, e.encode_gauge(v))
     }
 
@@ -98,7 +98,7 @@ impl<'a> MetricEncoder<'a> {
         sum: f64,
         count: u64,
         buckets: &[(f64, u64)],
-        exemplars: Option<&HashMap<usize, Exemplar<S, f64>>>,
+        exemplars: Option<&HashMap<usize, Exemplar<S>>>,
     ) -> Result<(), std::fmt::Error> {
         for_both!(self, e, e.encode_histogram(sum, count, buckets, exemplars))
     }
@@ -320,145 +320,19 @@ impl<'a> EncodeLabelValue for u64 {
     }
 }
 
-pub trait EncodeGaugeValue {
-    /// Encode the given instance in the OpenMetrics text encoding.
-    fn encode(&self, encoder: &mut GaugeValueEncoder) -> Result<(), std::fmt::Error>;
-}
-
-impl EncodeGaugeValue for i64 {
-    fn encode(&self, encoder: &mut GaugeValueEncoder) -> Result<(), std::fmt::Error> {
-        encoder.encode_i64(*self)
-    }
-}
-
-impl EncodeGaugeValue for f64 {
-    fn encode(&self, encoder: &mut GaugeValueEncoder) -> Result<(), std::fmt::Error> {
-        encoder.encode_f64(*self)
-    }
-}
-
-pub enum GaugeValueEncoder<'a> {
-    Text(text::GaugeValueEncoder<'a>),
-    Protobuf(proto::GaugeValueEncoder),
+#[derive(Debug, Clone, Copy)]
+pub enum Number {
+    SignedInteger(i64),
+    UnsignedInteger(u64),
+    Double(f64),
 }
 
-impl<'a> GaugeValueEncoder<'a> {
-    fn encode_f64(&mut self, v: f64) -> Result<(), std::fmt::Error> {
+impl Number {
+    pub fn as_f64(self) -> f64 {
         match self {
-            GaugeValueEncoder::Text(e) => e.encode_f64(v),
-            GaugeValueEncoder::Protobuf(e) => e.encode_f64(v),
+            Number::SignedInteger(i) => i as f64,
+            Number::UnsignedInteger(i) => i as f64,
+            Number::Double(d) => d,
         }
     }
-
-    fn encode_i64(&mut self, v: i64) -> Result<(), std::fmt::Error> {
-        match self {
-            GaugeValueEncoder::Text(e) => e.encode_i64(v),
-            GaugeValueEncoder::Protobuf(e) => e.encode_i64(v),
-        }
-    }
-}
-
-impl<'a> From<text::GaugeValueEncoder<'a>> for GaugeValueEncoder<'a> {
-    fn from(e: text::GaugeValueEncoder<'a>) -> Self {
-        GaugeValueEncoder::Text(e)
-    }
-}
-
-impl<'a> From<proto::GaugeValueEncoder> for GaugeValueEncoder<'a> {
-    fn from(e: proto::GaugeValueEncoder) -> Self {
-        GaugeValueEncoder::Protobuf(e)
-    }
-}
-
-pub trait EncodeCounterValue {
-    /// Encode the given instance in the OpenMetrics text encoding.
-    fn encode(&self, encoder: &mut CounterValueEncoder) -> Result<(), std::fmt::Error>;
-}
-
-impl EncodeCounterValue for u64 {
-    fn encode(&self, encoder: &mut CounterValueEncoder) -> Result<(), std::fmt::Error> {
-        encoder.encode_u64(*self)
-    }
-}
-
-impl EncodeCounterValue for f64 {
-    fn encode(&self, encoder: &mut CounterValueEncoder) -> Result<(), std::fmt::Error> {
-        encoder.encode_f64(*self)
-    }
-}
-
-pub enum CounterValueEncoder<'a> {
-    Text(text::CounterValueEncoder<'a>),
-    Protobuf(proto::CounterValueEncoder),
-}
-
-impl<'a> CounterValueEncoder<'a> {
-    fn encode_f64(&mut self, v: f64) -> Result<(), std::fmt::Error> {
-        match self {
-            CounterValueEncoder::Text(e) => e.encode_f64(v),
-            CounterValueEncoder::Protobuf(e) => e.encode_f64(v),
-        }
-    }
-
-    fn encode_u64(&mut self, v: u64) -> Result<(), std::fmt::Error> {
-        match self {
-            CounterValueEncoder::Text(e) => e.encode_u64(v),
-            CounterValueEncoder::Protobuf(e) => e.encode_u64(v),
-        }
-    }
-}
-
-pub trait EncodeExemplarValue {
-    /// Encode the given instance in the OpenMetrics text encoding.
-    fn encode(&self, encoder: ExemplarValueEncoder) -> Result<(), std::fmt::Error>;
-}
-
-impl EncodeExemplarValue for f64 {
-    fn encode(&self, mut encoder: ExemplarValueEncoder) -> Result<(), std::fmt::Error> {
-        encoder.encode(*self)
-    }
-}
-
-impl EncodeExemplarValue for u64 {
-    fn encode(&self, mut encoder: ExemplarValueEncoder) -> Result<(), std::fmt::Error> {
-        encoder.encode(*self as f64)
-    }
-}
-
-impl<'a> From<text::CounterValueEncoder<'a>> for CounterValueEncoder<'a> {
-    fn from(e: text::CounterValueEncoder<'a>) -> Self {
-        CounterValueEncoder::Text(e)
-    }
-}
-
-impl<'a> From<proto::CounterValueEncoder> for CounterValueEncoder<'a> {
-    fn from(e: proto::CounterValueEncoder) -> Self {
-        CounterValueEncoder::Protobuf(e)
-    }
-}
-
-pub enum ExemplarValueEncoder<'a> {
-    Text(text::ExemplarValueEncoder<'a>),
-    Protobuf(proto::ExemplarValueEncoder<'a>),
-}
-
-impl<'a> ExemplarValueEncoder<'a> {
-    fn encode(&mut self, v: f64) -> Result<(), std::fmt::Error> {
-        match self {
-            ExemplarValueEncoder::Text(e) => e.encode(v),
-            ExemplarValueEncoder::Protobuf(e) => e.encode(v),
-        }
-    }
-}
-
-impl<'a> From<text::ExemplarValueEncoder<'a>> for ExemplarValueEncoder<'a> {
-    fn from(e: text::ExemplarValueEncoder<'a>) -> Self {
-        ExemplarValueEncoder::Text(e)
-    }
-}
-
-impl<'a> From<proto::ExemplarValueEncoder<'a>> for ExemplarValueEncoder<'a> {
-    fn from(e: proto::ExemplarValueEncoder<'a>) -> Self {
-        ExemplarValueEncoder::Protobuf(e)
-    }
 }