Address comments

Author: howardjohn

src/encoding/text.rs

@@ -1,7 +1,7 @@
 //! Open Metrics text format implementation.
 //!
 //! ```
-//! # use prometheus_client::encoding::text::{encode, encode_registry, encode_eof};
+//! # use prometheus_client::encoding::text::{encode, encode_registry, encode_eof, EncodeError};
 //! # use prometheus_client::metrics::counter::Counter;
 //! # use prometheus_client::registry::Registry;
 //! #
@@ -45,9 +45,58 @@ use crate::metrics::MetricType;
 use crate::registry::{Prefix, Registry, Unit};
 
 use std::borrow::Cow;
+use std::cell::Cell;
 use std::collections::HashMap;
 use std::fmt::Write;
 
+thread_local! {
+    static UNSUPPORTED_NATIVE_HISTOGRAM: Cell<bool> = Cell::new(false);
+}
+
+/// Error returned by text encoding.
+#[derive(Clone, Copy, Debug)]
+pub enum EncodeError {
+    /// Formatting failed while writing text output.
+    Fmt(std::fmt::Error),
+    /// The OpenMetrics text encoder does not support native-only histograms.
+    UnsupportedNativeHistogram,
+}
+
+impl std::fmt::Display for EncodeError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            EncodeError::Fmt(_) => f.write_str("failed to encode metrics into OpenMetrics text"),
+            EncodeError::UnsupportedNativeHistogram => {
+                f.write_str("OpenMetrics text encoding does not support native-only histograms")
+            }
+        }
+    }
+}
+
+impl std::error::Error for EncodeError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            EncodeError::Fmt(err) => Some(err),
+            EncodeError::UnsupportedNativeHistogram => None,
+        }
+    }
+}
+
+impl From<std::fmt::Error> for EncodeError {
+    fn from(err: std::fmt::Error) -> Self {
+        if UNSUPPORTED_NATIVE_HISTOGRAM.with(|unsupported| unsupported.replace(false)) {
+            EncodeError::UnsupportedNativeHistogram
+        } else {
+            EncodeError::Fmt(err)
+        }
+    }
+}
+
+fn mark_unsupported_native_histogram() -> std::fmt::Error {
+    UNSUPPORTED_NATIVE_HISTOGRAM.with(|unsupported| unsupported.set(true));
+    std::fmt::Error
+}
+
 /// Encode both the metrics registered with the provided [`Registry`] and the
 /// EOF marker into the provided [`Write`]r using the OpenMetrics text format.
 ///
@@ -84,14 +133,14 @@ use std::fmt::Write;
 /// // Encode the complete OpenMetrics exposition into the buffer
 /// let mut buffer = String::new();
 /// encode(&mut buffer, &registry)?;
-/// # Ok::<(), std::fmt::Error>(())
+/// # Ok::<(), prometheus_client::encoding::text::EncodeError>(())
 /// ```
-pub fn encode<W>(writer: &mut W, registry: &Registry) -> Result<(), std::fmt::Error>
+pub fn encode<W>(writer: &mut W, registry: &Registry) -> Result<(), EncodeError>
 where
     W: Write,
 {
     encode_registry(writer, registry)?;
-    encode_eof(writer)
+    encode_eof(writer).map_err(EncodeError::Fmt)
 }
 
 /// Encode the metrics registered with the provided [`Registry`] into the
@@ -138,13 +187,16 @@ where
 ///
 /// // Encode the gauge registry into the buffer
 /// encode_registry(&mut buffer, &reg_gauge)?;
-/// # Ok::<(), std::fmt::Error>(())
+/// # Ok::<(), prometheus_client::encoding::text::EncodeError>(())
 /// ```
-pub fn encode_registry<W>(writer: &mut W, registry: &Registry) -> Result<(), std::fmt::Error>
+pub fn encode_registry<W>(writer: &mut W, registry: &Registry) -> Result<(), EncodeError>
 where
     W: Write,
 {
-    registry.encode(&mut DescriptorEncoder::new(writer).into())
+    UNSUPPORTED_NATIVE_HISTOGRAM.with(|unsupported| unsupported.set(false));
+    registry
+        .encode(&mut DescriptorEncoder::new(writer).into())
+        .map_err(EncodeError::from)
 }
 
 /// Encode the EOF marker into the provided [`Write`]r using the OpenMetrics
@@ -175,7 +227,7 @@ where
 ///
 /// // Encode EOF marker to complete the message
 /// encode_eof(&mut buffer)?;
-/// # Ok::<(), std::fmt::Error>(())
+/// # Ok::<(), prometheus_client::encoding::text::EncodeError>(())
 /// ```
 pub fn encode_eof<W>(writer: &mut W) -> Result<(), std::fmt::Error>
 where
@@ -455,7 +507,7 @@ impl MetricEncoder<'_> {
         _native: NativeHistogram<'_>,
     ) -> Result<(), std::fmt::Error> {
         if buckets.is_empty() {
-            return Err(std::fmt::Error);
+            return Err(mark_unsupported_native_histogram());
         }
 
         self.encode_histogram(sum, count, buckets, exemplars)
@@ -990,7 +1042,10 @@ mod tests {
         histogram.observe(1.0);
 
         let mut encoded = String::new();
-        assert!(encode(&mut encoded, &registry).is_err());
+        assert!(matches!(
+            encode(&mut encoded, &registry),
+            Err(EncodeError::UnsupportedNativeHistogram)
+        ));
     }
 
     #[test]

src/metrics/exemplar.rs

@@ -275,8 +275,9 @@ impl<S> HistogramWithExemplars<S> {
 impl<S: EncodeLabelSet> EncodeMetric for HistogramWithExemplars<S> {
     fn encode(&self, mut encoder: MetricEncoder) -> Result<(), std::fmt::Error> {
         let inner = self.inner();
-        let (sum, count, buckets) = inner.histogram.get();
-        encoder.encode_histogram(sum, count, &buckets, Some(&inner.exemplars))
+        inner
+            .histogram
+            .encode_with_exemplars(&mut encoder, Some(&inner.exemplars))
     }
 
     fn metric_type(&self) -> MetricType {