From b255f8c1c82d4cfbe88f71d1e9d3e055c47bd258 Mon Sep 17 00:00:00 2001
From: Evan Schwartz <3262610+emschwartz@users.noreply.github.com>
Date: Fri, 21 Apr 2023 15:58:16 +0200
Subject: [PATCH 01/16] [WIP]

---
 autometrics/Cargo.toml                       |  4 ++
 autometrics/src/labels.rs                    | 62 +++++++++++++++++---
 autometrics/src/lib.rs                       |  6 +-
 autometrics/src/objectives.rs                | 25 ++++++++
 autometrics/src/tracker/mod.rs               |  2 +
 autometrics/src/tracker/prometheus_client.rs | 60 +++++++++++++++++++
 6 files changed, 150 insertions(+), 9 deletions(-)
 create mode 100644 autometrics/src/tracker/prometheus_client.rs

diff --git a/autometrics/Cargo.toml b/autometrics/Cargo.toml
index 6af6658b..4b9272f6 100644
--- a/autometrics/Cargo.toml
+++ b/autometrics/Cargo.toml
@@ -16,6 +16,7 @@ default = ["opentelemetry"]
 metrics = ["dep:metrics"]
 opentelemetry = ["opentelemetry_api"]
 prometheus = ["const_format", "dep:prometheus", "once_cell"]
+prometheus-client = ["dep:prometheus-client", "once_cell"]
 prometheus-exporter = [
   "metrics-exporter-prometheus",
   "once_cell",
@@ -45,6 +46,9 @@ prometheus = { version = "0.13", default-features = false, optional = true }
 # Used for prometheus feature
 const_format = { version = "0.2", features = ["rust_1_51"], optional = true }
 
+# Used for prometheus-client feature
+prometheus-client = { version = "0.20", optional = true }
+
 [dev-dependencies]
 regex = "1.7"
 http = "0.2"
diff --git a/autometrics/src/labels.rs b/autometrics/src/labels.rs
index 56087d9d..5bc63845 100644
--- a/autometrics/src/labels.rs
+++ b/autometrics/src/labels.rs
@@ -1,10 +1,19 @@
 use crate::{constants::*, objectives::*};
+use prometheus_client::encoding::EncodeLabelKey;
+#[cfg(feature = "prometheus-client")]
+use prometheus_client::encoding::{
+    EncodeLabelSet, EncodeLabelValue, LabelSetEncoder, LabelValueEncoder,
+};
 use std::ops::Deref;
 
 pub(crate) type Label = (&'static str, &'static str);
 type ResultAndReturnTypeLabels = (&'static str, Option<&'static str>);
 
 /// These are the labels used for the `build_info` metric.
+#[cfg_attr(
+    feature = "prometheus-client",
+    derive(EncodeLabelSet, Debug, Clone, PartialEq, Eq, Hash)
+)]
 pub struct BuildInfoLabels {
     pub(crate) version: &'static str,
     pub(crate) commit: &'static str,
@@ -21,12 +30,38 @@ impl BuildInfoLabels {
 }
 
 /// These are the labels used for the `function.calls.count` metric.
+#[cfg_attr(
+    feature = "prometheus-client",
+    derive(EncodeLabelSet, Debug, Clone, PartialEq, Eq, Hash)
+)]
 pub struct CounterLabels {
     pub(crate) function: &'static str,
     pub(crate) module: &'static str,
     pub(crate) caller: &'static str,
-    pub(crate) result: Option<ResultAndReturnTypeLabels>,
-    pub(crate) objective: Option<(&'static str, ObjectivePercentile)>,
+    pub(crate) result: Option<ResultLabel>,
+    pub(crate) ok: Option<&'static str>,
+    pub(crate) error: Option<&'static str>,
+    pub(crate) objective_name: Option<&'static str>,
+    pub(crate) objective_percentile: Option<ObjectivePercentile>,
+}
+
+#[cfg_attr(
+    feature = "prometheus-client",
+    derive(Debug, Clone, PartialEq, Eq, Hash)
+)]
+pub(crate) enum ResultLabel {
+    Ok,
+    Error,
+}
+
+#[cfg(feature = "prometheus-client")]
+impl EncodeLabelValue for ResultLabel {
+    fn encode(&self, encoder: &mut LabelValueEncoder) -> Result<(), std::fmt::Error> {
+        match self {
+            ResultLabel::Ok => OK_KEY.encode(encoder),
+            ResultLabel::Error => ERROR_KEY.encode(encoder),
+        }
+    }
 }
 
 impl CounterLabels {
@@ -37,21 +72,22 @@ impl CounterLabels {
         result: Option<ResultAndReturnTypeLabels>,
         objective: Option<Objective>,
     ) -> Self {
-        let objective = if let Some(objective) = objective {
+        let (objective_name, objective_percentile) = if let Some(objective) = objective {
             if let Some(success_rate) = objective.success_rate {
-                Some((objective.name, success_rate))
+                (objective.name, success_rate)
             } else {
-                None
+                ("", "")
             }
         } else {
-            None
+            ("", "")
         };
         Self {
             function,
             module,
             caller,
+            objective_name,
+            objective_percentile,
             result,
-            objective,
         }
     }
 
@@ -77,11 +113,17 @@ impl CounterLabels {
 }
 
 /// These are the labels used for the `function.calls.duration` metric.
+#[cfg_attr(
+    feature = "prometheus-client",
+    derive(EncodeLabelSet, Debug, Clone, PartialEq, Eq, Hash)
+)]
 pub struct HistogramLabels {
     pub function: &'static str,
     pub module: &'static str,
     /// The SLO name, objective percentile, and latency threshold
-    pub objective: Option<(&'static str, ObjectivePercentile, ObjectiveLatency)>,
+    pub objective_name: &'static str,
+    pub objective_percentile: ObjectivePercentile,
+    pub objective_latency_threshold: ObjectiveLatency,
 }
 
 impl HistogramLabels {
@@ -117,6 +159,10 @@ impl HistogramLabels {
 }
 
 /// These are the labels used for the `function.calls.concurrent` metric.
+#[cfg_attr(
+    feature = "prometheus-client",
+    derive(EncodeLabelSet, Debug, Clone, PartialEq, Eq, Hash)
+)]
 pub struct GaugeLabels {
     pub function: &'static str,
     pub module: &'static str,
diff --git a/autometrics/src/lib.rs b/autometrics/src/lib.rs
index d786b8da..25744ce2 100644
--- a/autometrics/src/lib.rs
+++ b/autometrics/src/lib.rs
@@ -140,7 +140,11 @@ pub use self::prometheus_exporter::*;
 
 /// We use the histogram buckets recommended by the OpenTelemetry specification
 /// https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk.md#explicit-bucket-histogram-aggregation
-#[cfg(any(feature = "prometheus", feature = "prometheus-exporter"))]
+#[cfg(any(
+    feature = "prometheus",
+    feature = "prometheus-client",
+    feature = "prometheus-exporter"
+))]
 pub(crate) const HISTOGRAM_BUCKETS: [f64; 14] = [
     0.005, 0.01, 0.025, 0.05, 0.075, 0.1, 0.25, 0.5, 0.75, 1.0, 2.5, 5.0, 7.5, 10.0,
 ];
diff --git a/autometrics/src/objectives.rs b/autometrics/src/objectives.rs
index 4b45d592..53362725 100644
--- a/autometrics/src/objectives.rs
+++ b/autometrics/src/objectives.rs
@@ -1,3 +1,6 @@
+#[cfg(feature = "prometheus-client")]
+use prometheus_client::encoding::{EncodeLabelValue, LabelValueEncoder};
+
 /// This represents a Service-Level Objective (SLO) for a function or group of functions.
 /// The objective should be given a descriptive name and can represent
 /// a success rate and/or latency objective.
@@ -90,6 +93,10 @@ impl Objective {
 }
 
 /// The percentage of requests that must meet the given criteria (success rate or latency).
+#[cfg_attr(
+    feature = "prometheus-client",
+    derive(Clone, Debug, PartialEq, Eq, Hash)
+)]
 #[non_exhaustive]
 pub enum ObjectivePercentile {
     /// 90%
@@ -123,7 +130,18 @@ impl ObjectivePercentile {
     }
 }
 
+#[cfg(feature = "prometheus-client")]
+impl EncodeLabelValue for ObjectivePercentile {
+    fn encode(&self, encoder: &mut LabelValueEncoder) -> Result<(), std::fmt::Error> {
+        self.as_str().encode(encoder)
+    }
+}
+
 /// The latency threshold, in milliseoncds, for a given objective.
+#[cfg_attr(
+    feature = "prometheus-client",
+    derive(Clone, Debug, PartialEq, Eq, Hash)
+)]
 #[non_exhaustive]
 pub enum ObjectiveLatency {
     /// 5 milliseconds
@@ -203,3 +221,10 @@ impl ObjectiveLatency {
         }
     }
 }
+
+#[cfg(feature = "prometheus-client")]
+impl EncodeLabelValue for ObjectiveLatency {
+    fn encode(&self, encoder: &mut LabelValueEncoder) -> Result<(), std::fmt::Error> {
+        self.as_str().encode(encoder)
+    }
+}
diff --git a/autometrics/src/tracker/mod.rs b/autometrics/src/tracker/mod.rs
index e5211e3f..a53f0764 100644
--- a/autometrics/src/tracker/mod.rs
+++ b/autometrics/src/tracker/mod.rs
@@ -6,6 +6,8 @@ mod metrics;
 mod opentelemetry;
 #[cfg(feature = "prometheus")]
 mod prometheus;
+#[cfg(feature = "prometheus-client")]
+mod prometheus_client;
 
 // By default, use the opentelemetry crate
 #[cfg(all(
diff --git a/autometrics/src/tracker/prometheus_client.rs b/autometrics/src/tracker/prometheus_client.rs
new file mode 100644
index 00000000..807e7896
--- /dev/null
+++ b/autometrics/src/tracker/prometheus_client.rs
@@ -0,0 +1,60 @@
+use super::TrackMetrics;
+use crate::labels::{BuildInfoLabels, CounterLabels, GaugeLabels, HistogramLabels};
+use crate::{constants::*, HISTOGRAM_BUCKETS};
+use once_cell::sync::Lazy;
+use prometheus_client::metrics::{
+    counter::Counter, family::Family, gauge::Gauge, histogram::Histogram,
+};
+use prometheus_client::registry::Registry;
+
+pub static PROMETHEUS_CLIENT_REGISTRY: Lazy<Registry> = Lazy::new(|| <Registry>::default());
+
+static METRICS: Lazy<Metrics> = Lazy::new(|| {
+    let counter = Family::<CounterLabels, Counter>::default();
+    PROMETHEUS_CLIENT_REGISTRY.register(COUNTER_NAME, COUNTER_DESCRIPTION, counter.clone());
+
+    let histogram = Family::<HistogramLabels, Histogram>::new_with_constructor(|| {
+        Histogram::new(HISTOGRAM_BUCKETS.into_iter())
+    });
+    PROMETHEUS_CLIENT_REGISTRY.register(HISTOGRAM_NAME, HISTOGRAM_DESCRIPTION, histogram.clone());
+
+    let gauge = Family::<GaugeLabels, Gauge>::default();
+    PROMETHEUS_CLIENT_REGISTRY.register(GAUGE_NAME, GAUGE_DESCRIPTION, gauge.clone());
+
+    let build_info = Family::<BuildInfoLabels, Gauge>::default();
+    PROMETHEUS_CLIENT_REGISTRY.register(
+        BUILD_INFO_NAME,
+        BUILD_INFO_DESCRIPTION,
+        build_info.clone(),
+    );
+
+    Metrics {
+        counter,
+        histogram,
+        gauge,
+        build_info,
+    }
+});
+
+struct Metrics {
+    counter: Family<CounterLabels, Counter>,
+    histogram: Family<HistogramLabels, Histogram>,
+    gauge: Family<GaugeLabels, Gauge>,
+    build_info: Family<BuildInfoLabels, Gauge>,
+}
+
+struct PrometheusClientTracker {}
+
+impl TrackMetrics for PrometheusClientTracker {
+    fn set_build_info(build_info_labels: &BuildInfoLabels) {
+        todo!()
+    }
+
+    fn start(gauge_labels: Option<&GaugeLabels>) -> Self {
+        todo!()
+    }
+
+    fn finish(self, counter_labels: &CounterLabels, histogram_labels: &HistogramLabels) {
+        todo!()
+    }
+}

From 7cbe05323782dc72f19b3bad9ea52489e069d716 Mon Sep 17 00:00:00 2001
From: Evan Schwartz <3262610+emschwartz@users.noreply.github.com>
Date: Tue, 16 May 2023 15:44:12 +0200
Subject: [PATCH 02/16] Update prometheus-client version

---
 autometrics/Cargo.toml    | 2 +-
 autometrics/src/labels.rs | 8 +++-----
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/autometrics/Cargo.toml b/autometrics/Cargo.toml
index 4b9272f6..efd89955 100644
--- a/autometrics/Cargo.toml
+++ b/autometrics/Cargo.toml
@@ -47,7 +47,7 @@ prometheus = { version = "0.13", default-features = false, optional = true }
 const_format = { version = "0.2", features = ["rust_1_51"], optional = true }
 
 # Used for prometheus-client feature
-prometheus-client = { version = "0.20", optional = true }
+prometheus-client = { version = "0.21.1", optional = true }
 
 [dev-dependencies]
 regex = "1.7"
diff --git a/autometrics/src/labels.rs b/autometrics/src/labels.rs
index 5bc63845..17351d48 100644
--- a/autometrics/src/labels.rs
+++ b/autometrics/src/labels.rs
@@ -1,8 +1,7 @@
 use crate::{constants::*, objectives::*};
-use prometheus_client::encoding::EncodeLabelKey;
 #[cfg(feature = "prometheus-client")]
 use prometheus_client::encoding::{
-    EncodeLabelSet, EncodeLabelValue, LabelSetEncoder, LabelValueEncoder,
+    EncodeLabelKey, EncodeLabelSet, EncodeLabelValue, LabelValueEncoder,
 };
 use std::ops::Deref;
 
@@ -58,8 +57,8 @@ pub(crate) enum ResultLabel {
 impl EncodeLabelValue for ResultLabel {
     fn encode(&self, encoder: &mut LabelValueEncoder) -> Result<(), std::fmt::Error> {
         match self {
-            ResultLabel::Ok => OK_KEY.encode(encoder),
-            ResultLabel::Error => ERROR_KEY.encode(encoder),
+            ResultLabel::Ok => EncodeLabelValue::encode(&OK_KEY, encoder),
+            ResultLabel::Error => EncodeLabelValue::encode(&ERROR_KEY, encoder),
         }
     }
 }
@@ -120,7 +119,6 @@ impl CounterLabels {
 pub struct HistogramLabels {
     pub function: &'static str,
     pub module: &'static str,
-    /// The SLO name, objective percentile, and latency threshold
     pub objective_name: &'static str,
     pub objective_percentile: ObjectivePercentile,
     pub objective_latency_threshold: ObjectiveLatency,

From 9e402eb41339d7dc00d981dc809dbbd735b74507 Mon Sep 17 00:00:00 2001
From: Evan Schwartz <3262610+emschwartz@users.noreply.github.com>
Date: Tue, 16 May 2023 17:10:37 +0200
Subject: [PATCH 03/16] Finish support for prometheus-client

---
 .github/workflows/ci.yml                     |  9 +-
 autometrics/src/labels.rs                    | 93 +++++++++++++-------
 autometrics/src/lib.rs                       |  3 +
 autometrics/src/prometheus_exporter.rs       | 15 ++++
 autometrics/src/tracker/metrics.rs           |  2 +-
 autometrics/src/tracker/mod.rs               |  2 +-
 autometrics/src/tracker/prometheus.rs        | 48 ++++------
 autometrics/src/tracker/prometheus_client.rs | 76 +++++++++++-----
 8 files changed, 161 insertions(+), 87 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 68452cf4..946345fe 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -17,14 +17,15 @@ jobs:
       - uses: dtolnay/rust-toolchain@stable
       - uses: Swatinem/rust-cache@v2
 
-      # Build the packages using the different feature flags
+      # Build the packages
       - run: cargo build
-      - run: cargo build --features=metrics
-      - run: cargo build --features=prometheus
       - run: cargo build --features=custom-objective-percentile,custom-objective-latency
 
-      # Run the tests
+      # Run the tests with each of the different metrics libraries
       - run: cargo test --features=prometheus-exporter
+      - run: cargo test --no-default-features --features=prometheus-exporter,metrics --tests
+      - run: cargo test --no-default-features --features=prometheus-exporter,prometheus --tests
+      - run: cargo test --no-default-features --features=prometheus-exporter,prometheus-client --tests
 
       # Compile the examples
       - run: cargo build --package example-axum
diff --git a/autometrics/src/labels.rs b/autometrics/src/labels.rs
index 3087d55a..8c0f05e8 100644
--- a/autometrics/src/labels.rs
+++ b/autometrics/src/labels.rs
@@ -1,8 +1,6 @@
 use crate::{constants::*, objectives::*};
 #[cfg(feature = "prometheus-client")]
-use prometheus_client::encoding::{
-    EncodeLabelKey, EncodeLabelSet, EncodeLabelValue, LabelValueEncoder,
-};
+use prometheus_client::encoding::{EncodeLabelSet, EncodeLabelValue, LabelValueEncoder};
 use std::ops::Deref;
 
 pub(crate) type Label = (&'static str, &'static str);
@@ -62,6 +60,15 @@ pub(crate) enum ResultLabel {
     Error,
 }
 
+impl ResultLabel {
+    pub(crate) const fn as_str(&self) -> &'static str {
+        match self {
+            ResultLabel::Ok => OK_KEY,
+            ResultLabel::Error => ERROR_KEY,
+        }
+    }
+}
+
 #[cfg(feature = "prometheus-client")]
 impl EncodeLabelValue for ResultLabel {
     fn encode(&self, encoder: &mut LabelValueEncoder) -> Result<(), std::fmt::Error> {
@@ -82,12 +89,21 @@ impl CounterLabels {
     ) -> Self {
         let (objective_name, objective_percentile) = if let Some(objective) = objective {
             if let Some(success_rate) = objective.success_rate {
-                (objective.name, success_rate)
+                (Some(objective.name), Some(success_rate))
             } else {
-                ("", "")
+                (None, None)
             }
         } else {
-            ("", "")
+            (None, None)
+        };
+        let (result, ok, error) = if let Some((result, return_value_type)) = result {
+            match result {
+                OK_KEY => (Some(ResultLabel::Ok), return_value_type, None),
+                ERROR_KEY => (Some(ResultLabel::Error), None, return_value_type),
+                _ => (None, None, None),
+            }
+        } else {
+            (None, None, None)
         };
         Self {
             function,
@@ -96,6 +112,8 @@ impl CounterLabels {
             objective_name,
             objective_percentile,
             result,
+            ok,
+            error,
         }
     }
 
@@ -105,15 +123,20 @@ impl CounterLabels {
             (MODULE_KEY, self.module),
             (CALLER_KEY, self.caller),
         ];
-        if let Some((result, return_value_type)) = self.result {
-            labels.push((RESULT_KEY, result));
-            if let Some(return_value_type) = return_value_type {
-                labels.push((result, return_value_type));
-            }
+        if let Some(result) = &self.result {
+            labels.push((RESULT_KEY, result.as_str()));
+        }
+        if let Some(ok) = self.ok {
+            labels.push((OK_KEY, ok));
+        }
+        if let Some(error) = self.error {
+            labels.push((ERROR_KEY, error));
         }
-        if let Some((name, percentile)) = &self.objective {
-            labels.push((OBJECTIVE_NAME, name));
-            labels.push((OBJECTIVE_PERCENTILE, percentile.as_str()));
+        if let Some(objective_name) = self.objective_name {
+            labels.push((OBJECTIVE_NAME, objective_name));
+        }
+        if let Some(objective_percentile) = &self.objective_percentile {
+            labels.push((OBJECTIVE_PERCENTILE, objective_percentile.as_str()));
         }
 
         labels
@@ -128,37 +151,47 @@ impl CounterLabels {
 pub struct HistogramLabels {
     pub function: &'static str,
     pub module: &'static str,
-    pub objective_name: &'static str,
-    pub objective_percentile: ObjectivePercentile,
-    pub objective_latency_threshold: ObjectiveLatency,
+    pub objective_name: Option<&'static str>,
+    pub objective_percentile: Option<ObjectivePercentile>,
+    pub objective_latency_threshold: Option<ObjectiveLatency>,
 }
 
 impl HistogramLabels {
     pub fn new(function: &'static str, module: &'static str, objective: Option<Objective>) -> Self {
-        let objective = if let Some(objective) = objective {
-            if let Some((latency, percentile)) = objective.latency {
-                Some((objective.name, percentile, latency))
+        let (objective_name, objective_percentile, objective_latency_threshold) =
+            if let Some(objective) = objective {
+                if let Some((latency, percentile)) = objective.latency {
+                    (Some(objective.name), Some(percentile), Some(latency))
+                } else {
+                    (None, None, None)
+                }
             } else {
-                None
-            }
-        } else {
-            None
-        };
+                (None, None, None)
+            };
 
         Self {
             function,
             module,
-            objective,
+            objective_name,
+            objective_percentile,
+            objective_latency_threshold,
         }
     }
 
     pub fn to_vec(&self) -> Vec<Label> {
         let mut labels = vec![(FUNCTION_KEY, self.function), (MODULE_KEY, self.module)];
 
-        if let Some((name, percentile, latency)) = &self.objective {
-            labels.push((OBJECTIVE_NAME, name));
-            labels.push((OBJECTIVE_PERCENTILE, percentile.as_str()));
-            labels.push((OBJECTIVE_LATENCY_THRESHOLD, latency.as_str()));
+        if let Some(objective_name) = self.objective_name {
+            labels.push((OBJECTIVE_NAME, objective_name));
+        }
+        if let Some(objective_percentile) = &self.objective_percentile {
+            labels.push((OBJECTIVE_PERCENTILE, objective_percentile.as_str()));
+        }
+        if let Some(objective_latency_threshold) = &self.objective_latency_threshold {
+            labels.push((
+                OBJECTIVE_LATENCY_THRESHOLD,
+                objective_latency_threshold.as_str(),
+            ));
         }
 
         labels
diff --git a/autometrics/src/lib.rs b/autometrics/src/lib.rs
index e61bdd81..fef90131 100644
--- a/autometrics/src/lib.rs
+++ b/autometrics/src/lib.rs
@@ -186,6 +186,9 @@ pub use autometrics_macros::ResultLabels;
 #[cfg(feature = "prometheus-exporter")]
 pub use self::prometheus_exporter::*;
 
+#[cfg(feature = "prometheus-client")]
+pub use self::tracker::prometheus_client::PROMETHEUS_CLIENT_REGISTRY;
+
 /// We use the histogram buckets recommended by the OpenTelemetry specification
 /// https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk.md#explicit-bucket-histogram-aggregation
 #[cfg(any(
diff --git a/autometrics/src/prometheus_exporter.rs b/autometrics/src/prometheus_exporter.rs
index c2a657da..4d2ecfc5 100644
--- a/autometrics/src/prometheus_exporter.rs
+++ b/autometrics/src/prometheus_exporter.rs
@@ -30,6 +30,21 @@ impl GlobalPrometheus {
             output.push_str(&self.handle.render());
         }
 
+        #[cfg(feature = "prometheus-client")]
+        {
+            output.push('\n');
+            prometheus_client::encoding::text::encode(
+                &mut output,
+                &crate::PROMETHEUS_CLIENT_REGISTRY,
+            )
+            .map_err(|err| {
+                Error::Msg(format!(
+                    "Failed to encode prometheus-client metrics: {}",
+                    err
+                ))
+            })?;
+        }
+
         Ok(output)
     }
 }
diff --git a/autometrics/src/tracker/metrics.rs b/autometrics/src/tracker/metrics.rs
index 1e996cf5..77da3ee0 100644
--- a/autometrics/src/tracker/metrics.rs
+++ b/autometrics/src/tracker/metrics.rs
@@ -42,7 +42,7 @@ impl TrackMetrics for MetricsTracker {
         }
     }
 
-    fn finish<'a>(self, counter_labels: &CounterLabels, histogram_labels: &HistogramLabels) {
+    fn finish(self, counter_labels: &CounterLabels, histogram_labels: &HistogramLabels) {
         let duration = self.start.elapsed().as_secs_f64();
         register_counter!(COUNTER_NAME, &counter_labels.to_vec()).increment(1);
         register_histogram!(HISTOGRAM_NAME, &histogram_labels.to_vec()).record(duration);
diff --git a/autometrics/src/tracker/mod.rs b/autometrics/src/tracker/mod.rs
index a53f0764..f66d4ef5 100644
--- a/autometrics/src/tracker/mod.rs
+++ b/autometrics/src/tracker/mod.rs
@@ -7,7 +7,7 @@ mod opentelemetry;
 #[cfg(feature = "prometheus")]
 mod prometheus;
 #[cfg(feature = "prometheus-client")]
-mod prometheus_client;
+pub(crate) mod prometheus_client;
 
 // By default, use the opentelemetry crate
 #[cfg(all(
diff --git a/autometrics/src/tracker/prometheus.rs b/autometrics/src/tracker/prometheus.rs
index 77de384d..1e22974c 100644
--- a/autometrics/src/tracker/prometheus.rs
+++ b/autometrics/src/tracker/prometheus.rs
@@ -1,4 +1,4 @@
-use crate::labels::{BuildInfoLabels, CounterLabels, GaugeLabels, HistogramLabels};
+use crate::labels::{BuildInfoLabels, CounterLabels, GaugeLabels, HistogramLabels, ResultLabel};
 use crate::{constants::*, tracker::TrackMetrics, HISTOGRAM_BUCKETS};
 use const_format::{formatcp, str_replace};
 use once_cell::sync::Lazy;
@@ -107,27 +107,19 @@ impl TrackMetrics for PrometheusTracker {
                     counter_labels.function,
                     counter_labels.module,
                     counter_labels.caller,
-                    counter_labels.result.unwrap_or_default().0,
-                    if let Some((OK_KEY, Some(return_value_type))) = counter_labels.result {
-                        return_value_type
-                    } else {
-                        ""
+                    match counter_labels.result {
+                        Some(ResultLabel::Ok) => OK_KEY,
+                        Some(ResultLabel::Error) => ERROR_KEY,
+                        None => "",
                     },
-                    if let Some((ERROR_KEY, Some(return_value_type))) = counter_labels.result {
-                        return_value_type
-                    } else {
-                        ""
-                    },
-                    counter_labels
-                        .objective
-                        .as_ref()
-                        .map(|obj| obj.0)
-                        .unwrap_or(""),
+                    counter_labels.ok.unwrap_or_default(),
+                    counter_labels.error.unwrap_or_default(),
+                    counter_labels.objective_name.unwrap_or_default(),
                     counter_labels
-                        .objective
+                        .objective_percentile
                         .as_ref()
-                        .map(|obj| obj.1.as_str())
-                        .unwrap_or(""),
+                        .map(|p| p.as_str())
+                        .unwrap_or_default(),
                 ],
             )
             .inc();
@@ -136,21 +128,17 @@ impl TrackMetrics for PrometheusTracker {
             .with_label_values(&[
                 histogram_labels.function,
                 histogram_labels.module,
+                histogram_labels.objective_name.unwrap_or_default(),
                 histogram_labels
-                    .objective
-                    .as_ref()
-                    .map(|obj| obj.0)
-                    .unwrap_or(""),
-                histogram_labels
-                    .objective
+                    .objective_percentile
                     .as_ref()
-                    .map(|obj| obj.1.as_str())
-                    .unwrap_or(""),
+                    .map(|p| p.as_str())
+                    .unwrap_or_default(),
                 histogram_labels
-                    .objective
+                    .objective_latency_threshold
                     .as_ref()
-                    .map(|obj| obj.2.as_str())
-                    .unwrap_or(""),
+                    .map(|p| p.as_str())
+                    .unwrap_or_default(),
             ])
             .observe(duration);
 
diff --git a/autometrics/src/tracker/prometheus_client.rs b/autometrics/src/tracker/prometheus_client.rs
index 807e7896..2504d4dc 100644
--- a/autometrics/src/tracker/prometheus_client.rs
+++ b/autometrics/src/tracker/prometheus_client.rs
@@ -6,35 +6,36 @@ use prometheus_client::metrics::{
     counter::Counter, family::Family, gauge::Gauge, histogram::Histogram,
 };
 use prometheus_client::registry::Registry;
+use std::time::Instant;
 
-pub static PROMETHEUS_CLIENT_REGISTRY: Lazy<Registry> = Lazy::new(|| <Registry>::default());
+static REGISTRY_AND_METRICS: Lazy<(Registry, Metrics)> = Lazy::new(|| {
+    let mut registry = <Registry>::default();
 
-static METRICS: Lazy<Metrics> = Lazy::new(|| {
     let counter = Family::<CounterLabels, Counter>::default();
-    PROMETHEUS_CLIENT_REGISTRY.register(COUNTER_NAME, COUNTER_DESCRIPTION, counter.clone());
+    registry.register(COUNTER_NAME, COUNTER_DESCRIPTION, counter.clone());
 
     let histogram = Family::<HistogramLabels, Histogram>::new_with_constructor(|| {
         Histogram::new(HISTOGRAM_BUCKETS.into_iter())
     });
-    PROMETHEUS_CLIENT_REGISTRY.register(HISTOGRAM_NAME, HISTOGRAM_DESCRIPTION, histogram.clone());
+    registry.register(HISTOGRAM_NAME, HISTOGRAM_DESCRIPTION, histogram.clone());
 
     let gauge = Family::<GaugeLabels, Gauge>::default();
-    PROMETHEUS_CLIENT_REGISTRY.register(GAUGE_NAME, GAUGE_DESCRIPTION, gauge.clone());
+    registry.register(GAUGE_NAME, GAUGE_DESCRIPTION, gauge.clone());
 
     let build_info = Family::<BuildInfoLabels, Gauge>::default();
-    PROMETHEUS_CLIENT_REGISTRY.register(
-        BUILD_INFO_NAME,
-        BUILD_INFO_DESCRIPTION,
-        build_info.clone(),
-    );
-
-    Metrics {
-        counter,
-        histogram,
-        gauge,
-        build_info,
-    }
+    registry.register(BUILD_INFO_NAME, BUILD_INFO_DESCRIPTION, build_info.clone());
+
+    (
+        registry,
+        Metrics {
+            counter,
+            histogram,
+            gauge,
+            build_info,
+        },
+    )
 });
+pub static PROMETHEUS_CLIENT_REGISTRY: Lazy<&Registry> = Lazy::new(|| &REGISTRY_AND_METRICS.0);
 
 struct Metrics {
     counter: Family<CounterLabels, Counter>,
@@ -43,18 +44,51 @@ struct Metrics {
     build_info: Family<BuildInfoLabels, Gauge>,
 }
 
-struct PrometheusClientTracker {}
+struct PrometheusClientTracker {
+    gauge_labels: Option<GaugeLabels>,
+    start_time: Instant,
+}
 
 impl TrackMetrics for PrometheusClientTracker {
     fn set_build_info(build_info_labels: &BuildInfoLabels) {
-        todo!()
+        REGISTRY_AND_METRICS
+            .1
+            .build_info
+            .get_or_create(&build_info_labels)
+            .set(1);
     }
 
     fn start(gauge_labels: Option<&GaugeLabels>) -> Self {
-        todo!()
+        if let Some(gauge_labels) = gauge_labels {
+            REGISTRY_AND_METRICS
+                .1
+                .gauge
+                .get_or_create(&gauge_labels)
+                .inc();
+        }
+        Self {
+            gauge_labels: gauge_labels.cloned(),
+            start_time: Instant::now(),
+        }
     }
 
     fn finish(self, counter_labels: &CounterLabels, histogram_labels: &HistogramLabels) {
-        todo!()
+        REGISTRY_AND_METRICS
+            .1
+            .counter
+            .get_or_create(&counter_labels)
+            .inc();
+        REGISTRY_AND_METRICS
+            .1
+            .histogram
+            .get_or_create(&histogram_labels)
+            .observe(self.start_time.elapsed().as_secs_f64());
+        if let Some(gauge_labels) = self.gauge_labels {
+            REGISTRY_AND_METRICS
+                .1
+                .gauge
+                .get_or_create(&gauge_labels)
+                .dec();
+        }
     }
 }

From f29aae1c3a5c73f42a7b5ed7df881b560a99434d Mon Sep 17 00:00:00 2001
From: Evan Schwartz <3262610+emschwartz@users.noreply.github.com>
Date: Tue, 16 May 2023 17:17:55 +0200
Subject: [PATCH 04/16] Fix doc links

---
 autometrics/src/labels.rs                    | 5 +++--
 autometrics/src/tracker/prometheus_client.rs | 1 +
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/autometrics/src/labels.rs b/autometrics/src/labels.rs
index 8c0f05e8..1673669e 100644
--- a/autometrics/src/labels.rs
+++ b/autometrics/src/labels.rs
@@ -312,11 +312,12 @@ impl_trait_for_types!(GetStaticStr);
 /// The macro uses the autoref specialization trick through spez to get the labels for the type in a variety of circumstances.
 /// Specifically, if the value is a Result, it will add the ok or error label accordingly unless one or both of the types that
 /// the Result<T, E> is generic over implements the GetLabels trait. The label allows to override the inferred label, and the
-/// [`ResultLabels`](crate::result_labels) macro implements the GetLabels trait for the user using annotations.
+/// [`ResultLabels`](crate::ResultLabels) macro implements the GetLabels trait for the user using annotations.
 ///
 /// The macro is meant to be called with a reference as argument: `get_result_labels_for_value(&return_value)`
 ///
-/// Ref: https://github.com/dtolnay/case-studies/blob/master/autoref-specialization/README.md
+/// See: <https://github.com/dtolnay/case-studies/blob/master/autoref-specialization/README.md>
+#[doc(hidden)]
 #[macro_export]
 macro_rules! get_result_labels_for_value {
     ($e:expr) => {{
diff --git a/autometrics/src/tracker/prometheus_client.rs b/autometrics/src/tracker/prometheus_client.rs
index 2504d4dc..ad519972 100644
--- a/autometrics/src/tracker/prometheus_client.rs
+++ b/autometrics/src/tracker/prometheus_client.rs
@@ -35,6 +35,7 @@ static REGISTRY_AND_METRICS: Lazy<(Registry, Metrics)> = Lazy::new(|| {
         },
     )
 });
+/// The [`Registry`] used to collect metrics when the `prometheus-client` feature is enabled
 pub static PROMETHEUS_CLIENT_REGISTRY: Lazy<&Registry> = Lazy::new(|| &REGISTRY_AND_METRICS.0);
 
 struct Metrics {

From 11d052faa5f520a14ec0adcfaf0e40f72bb04808 Mon Sep 17 00:00:00 2001
From: Evan Schwartz <3262610+emschwartz@users.noreply.github.com>
Date: Tue, 16 May 2023 17:31:02 +0200
Subject: [PATCH 05/16] Ensure that prometheus-client is actually being used

---
 autometrics/Cargo.toml                       |  2 +-
 autometrics/src/tracker/mod.rs               | 21 +++++++++++++++++---
 autometrics/src/tracker/prometheus_client.rs |  2 +-
 3 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/autometrics/Cargo.toml b/autometrics/Cargo.toml
index ae8a30d9..42c47b59 100644
--- a/autometrics/Cargo.toml
+++ b/autometrics/Cargo.toml
@@ -23,7 +23,7 @@ prometheus-exporter = [
   "once_cell",
   "opentelemetry-prometheus",
   "opentelemetry_sdk",
-  "prometheus"
+  "dep:prometheus"
 ]
 custom-objective-percentile = []
 custom-objective-latency = []
diff --git a/autometrics/src/tracker/mod.rs b/autometrics/src/tracker/mod.rs
index f66d4ef5..dd7c9ce8 100644
--- a/autometrics/src/tracker/mod.rs
+++ b/autometrics/src/tracker/mod.rs
@@ -9,18 +9,33 @@ mod prometheus;
 #[cfg(feature = "prometheus-client")]
 pub(crate) mod prometheus_client;
 
+// Priority if multiple features are enabled:
+// 1. prometheus
+// 2. prometheus-client
+// 3. metrics
+// 4. opentelemetry (default)
+
 // By default, use the opentelemetry crate
 #[cfg(all(
     feature = "opentelemetry",
-    not(any(feature = "metrics", feature = "prometheus"))
+    not(any(
+        feature = "metrics",
+        feature = "prometheus",
+        feature = "prometheus-client"
+    ))
 ))]
 pub use self::opentelemetry::OpenTelemetryTracker as AutometricsTracker;
 
-// But use one of the other crates if either of those features are enabled
-#[cfg(all(feature = "metrics", not(feature = "prometheus")))]
+// But use one of the other crates if any of those features are enabled
+#[cfg(all(
+    feature = "metrics",
+    not(any(feature = "prometheus", feature = "prometheus-client"))
+))]
 pub use self::metrics::MetricsTracker as AutometricsTracker;
 #[cfg(feature = "prometheus")]
 pub use self::prometheus::PrometheusTracker as AutometricsTracker;
+#[cfg(all(feature = "prometheus-client", not(feature = "prometheus")))]
+pub use self::prometheus_client::PrometheusClientTracker as AutometricsTracker;
 
 pub trait TrackMetrics {
     fn set_build_info(build_info_labels: &BuildInfoLabels);
diff --git a/autometrics/src/tracker/prometheus_client.rs b/autometrics/src/tracker/prometheus_client.rs
index ad519972..04b5e682 100644
--- a/autometrics/src/tracker/prometheus_client.rs
+++ b/autometrics/src/tracker/prometheus_client.rs
@@ -45,7 +45,7 @@ struct Metrics {
     build_info: Family<BuildInfoLabels, Gauge>,
 }
 
-struct PrometheusClientTracker {
+pub struct PrometheusClientTracker {
     gauge_labels: Option<GaugeLabels>,
     start_time: Instant,
 }

From 9817601e085e28b37ae329c7295cbc1d2e947e01 Mon Sep 17 00:00:00 2001
From: Evan Schwartz <3262610+emschwartz@users.noreply.github.com>
Date: Tue, 16 May 2023 17:51:00 +0200
Subject: [PATCH 06/16] Work on fixing tests, remove const_format dep

---
 autometrics/Cargo.toml                       |  5 +--
 autometrics/src/constants.rs                 | 10 +++++-
 autometrics/src/labels.rs                    |  4 +--
 autometrics/src/tracker/prometheus.rs        |  9 +----
 autometrics/src/tracker/prometheus_client.rs | 14 ++++++--
 autometrics/tests/integration_test.rs        | 36 +++++++++++---------
 6 files changed, 44 insertions(+), 34 deletions(-)

diff --git a/autometrics/Cargo.toml b/autometrics/Cargo.toml
index 42c47b59..b903a55e 100644
--- a/autometrics/Cargo.toml
+++ b/autometrics/Cargo.toml
@@ -16,7 +16,7 @@ readme = "README.md"
 default = ["opentelemetry"]
 metrics = ["dep:metrics"]
 opentelemetry = ["opentelemetry_api"]
-prometheus = ["const_format", "dep:prometheus", "once_cell"]
+prometheus = ["dep:prometheus", "once_cell"]
 prometheus-client = ["dep:prometheus-client", "once_cell"]
 prometheus-exporter = [
   "metrics-exporter-prometheus",
@@ -45,9 +45,6 @@ opentelemetry-prometheus = { version = "0.11", optional = true }
 opentelemetry_sdk = { version = "0.18", default-features = false, features = ["metrics"], optional = true }
 prometheus = { version = "0.13", default-features = false, optional = true }
 
-# Used for prometheus feature
-const_format = { version = "0.2", features = ["rust_1_51"], optional = true }
-
 # Used for prometheus-client feature
 prometheus-client = { version = "0.21.1", optional = true }
 
diff --git a/autometrics/src/constants.rs b/autometrics/src/constants.rs
index 85cb8c3f..1f86375a 100644
--- a/autometrics/src/constants.rs
+++ b/autometrics/src/constants.rs
@@ -4,6 +4,11 @@ pub const HISTOGRAM_NAME: &str = "function.calls.duration";
 pub const GAUGE_NAME: &str = "function.calls.concurrent";
 pub const BUILD_INFO_NAME: &str = "build_info";
 
+// Prometheus-flavored metric names
+pub const COUNTER_NAME_PROMETHEUS: &str = "function_calls_count";
+pub const HISTOGRAM_NAME_PROMETHEUS: &str = "function_calls_duration";
+pub const GAUGE_NAME_PROMETHEUS: &str = "function_calls_concurrent";
+
 // Descriptions
 pub const COUNTER_DESCRIPTION: &str = "Autometrics counter for tracking function calls";
 pub const HISTOGRAM_DESCRIPTION: &str = "Autometrics histogram for tracking function call duration";
@@ -19,8 +24,11 @@ pub const RESULT_KEY: &'static str = "result";
 pub const OK_KEY: &'static str = "ok";
 pub const ERROR_KEY: &'static str = "error";
 pub const OBJECTIVE_NAME: &'static str = "objective.name";
+pub const OBJECTIVE_NAME_PROMETHEUS: &'static str = "objective_name";
 pub const OBJECTIVE_PERCENTILE: &'static str = "objective.percentile";
-pub const OBJECTIVE_LATENCY_THRESHOLD: &'static str = "objective.latency_threshold";
+pub const OBJECTIVE_PERCENTILE_PROMETHEUS: &'static str = "objective_percentile";
+pub const OBJECTIVE_LATENCY_THRESHOLD: &'static str = "objective.latency.threshold";
+pub const OBJECTIVE_LATENCY_THRESHOLD_PROMETHEUS: &'static str = "objective_latency_threshold";
 pub const VERSION_KEY: &'static str = "version";
 pub const COMMIT_KEY: &'static str = "commit";
 pub const BRANCH_KEY: &'static str = "branch";
diff --git a/autometrics/src/labels.rs b/autometrics/src/labels.rs
index 1673669e..8462de0c 100644
--- a/autometrics/src/labels.rs
+++ b/autometrics/src/labels.rs
@@ -12,9 +12,9 @@ pub type ResultAndReturnTypeLabels = (&'static str, Option<&'static str>);
     derive(EncodeLabelSet, Debug, Clone, PartialEq, Eq, Hash)
 )]
 pub struct BuildInfoLabels {
-    pub(crate) version: &'static str,
-    pub(crate) commit: &'static str,
     pub(crate) branch: &'static str,
+    pub(crate) commit: &'static str,
+    pub(crate) version: &'static str,
 }
 
 impl BuildInfoLabels {
diff --git a/autometrics/src/tracker/prometheus.rs b/autometrics/src/tracker/prometheus.rs
index 1e22974c..755867b0 100644
--- a/autometrics/src/tracker/prometheus.rs
+++ b/autometrics/src/tracker/prometheus.rs
@@ -9,13 +9,6 @@ use prometheus::{
 };
 use std::{sync::Once, time::Instant};
 
-const COUNTER_NAME_PROMETHEUS: &str = str_replace!(COUNTER_NAME, ".", "_");
-const HISTOGRAM_NAME_PROMETHEUS: &str = str_replace!(HISTOGRAM_NAME, ".", "_");
-const GAUGE_NAME_PROMETHEUS: &str = str_replace!(GAUGE_NAME, ".", "_");
-const OBJECTIVE_NAME_PROMETHEUS: &str = str_replace!(OBJECTIVE_NAME, ".", "_");
-const OBJECTIVE_PERCENTILE_PROMETHEUS: &str = str_replace!(OBJECTIVE_PERCENTILE, ".", "_");
-const OBJECTIVE_LATENCY_PROMETHEUS: &str = str_replace!(OBJECTIVE_LATENCY_THRESHOLD, ".", "_");
-
 static SET_BUILD_INFO: Once = Once::new();
 
 static COUNTER: Lazy<IntCounterVec> = Lazy::new(|| {
@@ -54,7 +47,7 @@ static HISTOGRAM: Lazy<HistogramVec> = Lazy::new(|| {
             MODULE_KEY,
             OBJECTIVE_NAME_PROMETHEUS,
             OBJECTIVE_PERCENTILE_PROMETHEUS,
-            OBJECTIVE_LATENCY_PROMETHEUS
+            OBJECTIVE_LATENCY_THRESHOLD_PROMETHEUS
         ]
     )
     .expect("Failed to register function_calls_duration histogram")
diff --git a/autometrics/src/tracker/prometheus_client.rs b/autometrics/src/tracker/prometheus_client.rs
index 04b5e682..3e83485e 100644
--- a/autometrics/src/tracker/prometheus_client.rs
+++ b/autometrics/src/tracker/prometheus_client.rs
@@ -12,15 +12,23 @@ static REGISTRY_AND_METRICS: Lazy<(Registry, Metrics)> = Lazy::new(|| {
     let mut registry = <Registry>::default();
 
     let counter = Family::<CounterLabels, Counter>::default();
-    registry.register(COUNTER_NAME, COUNTER_DESCRIPTION, counter.clone());
+    registry.register(
+        COUNTER_NAME_PROMETHEUS,
+        COUNTER_DESCRIPTION,
+        counter.clone(),
+    );
 
     let histogram = Family::<HistogramLabels, Histogram>::new_with_constructor(|| {
         Histogram::new(HISTOGRAM_BUCKETS.into_iter())
     });
-    registry.register(HISTOGRAM_NAME, HISTOGRAM_DESCRIPTION, histogram.clone());
+    registry.register(
+        HISTOGRAM_NAME_PROMETHEUS,
+        HISTOGRAM_DESCRIPTION,
+        histogram.clone(),
+    );
 
     let gauge = Family::<GaugeLabels, Gauge>::default();
-    registry.register(GAUGE_NAME, GAUGE_DESCRIPTION, gauge.clone());
+    registry.register(GAUGE_NAME_PROMETHEUS, GAUGE_DESCRIPTION, gauge.clone());
 
     let build_info = Family::<BuildInfoLabels, Gauge>::default();
     registry.register(BUILD_INFO_NAME, BUILD_INFO_DESCRIPTION, build_info.clone());
diff --git a/autometrics/tests/integration_test.rs b/autometrics/tests/integration_test.rs
index c78ecb3b..89288362 100644
--- a/autometrics/tests/integration_test.rs
+++ b/autometrics/tests/integration_test.rs
@@ -17,7 +17,7 @@ fn single_function() {
     let metrics = autometrics::encode_global_metrics().unwrap();
     println!("{}", metrics);
     let call_count_metric: Regex = Regex::new(
-        r#"function_calls_count\{\S*function="hello_world"\S*module="integration_test"\S*\} 2"#,
+        r#"function_calls_count(?:_total)?\{\S*function="hello_world"\S*module="integration_test"\S*\} 2"#,
     )
     .unwrap();
     let duration_metric: Regex = Regex::new(
@@ -51,9 +51,9 @@ fn impl_block() {
 
     let metrics = autometrics::encode_global_metrics().unwrap();
     let test_fn_count: Regex =
-        Regex::new(r#"function_calls_count\{\S*function="test_fn"\S*\} 1"#).unwrap();
+        Regex::new(r#"function_calls_count(?:_total)?\{\S*function="test_fn"\S*\} 1"#).unwrap();
     let test_method_count: Regex =
-        Regex::new(r#"function_calls_count\{\S*function="test_method"\S*\} 1"#).unwrap();
+        Regex::new(r#"function_calls_count(?:_total)?\{\S*function="test_method"\S*\} 1"#).unwrap();
     let test_fn_duration: Regex =
         Regex::new(r#"function_calls_duration_bucket\{\S*function="test_fn"\S*\}"#).unwrap();
     let test_method_duration: Regex =
@@ -83,13 +83,15 @@ fn result() {
     result_fn(false).ok();
 
     let metrics = autometrics::encode_global_metrics().unwrap();
-    let error_count: Regex =
-        Regex::new(r#"function_calls_count\{\S*function="result_fn"\S*result="error"\S*\} 2"#)
-            .unwrap();
+    let error_count: Regex = Regex::new(
+        r#"function_calls_count(?:_total)?\{\S*function="result_fn"\S*result="error"\S*\} 2"#,
+    )
+    .unwrap();
     assert!(error_count.is_match(&metrics));
-    let ok_count: Regex =
-        Regex::new(r#"function_calls_count\{\S*function="result_fn"\S*result="ok"\S*\} 1"#)
-            .unwrap();
+    let ok_count: Regex = Regex::new(
+        r#"function_calls_count(?:_total)?\{\S*function="result_fn"\S*result="ok"\S*\} 1"#,
+    )
+    .unwrap();
     assert!(ok_count.is_match(&metrics));
 }
 
@@ -106,9 +108,10 @@ fn ok_if() {
     ok_if_fn();
 
     let metrics = autometrics::encode_global_metrics().unwrap();
-    let error_count: Regex =
-        Regex::new(r#"function_calls_count\{\S*function="ok_if_fn"\S*result="error"\S*\} 1"#)
-            .unwrap();
+    let error_count: Regex = Regex::new(
+        r#"function_calls_count(?:_total)?\{\S*function="ok_if_fn"\S*result="error"\S*\} 1"#,
+    )
+    .unwrap();
     assert!(error_count.is_match(&metrics));
 }
 
@@ -125,9 +128,10 @@ fn error_if() {
     error_if_fn();
 
     let metrics = autometrics::encode_global_metrics().unwrap();
-    let error_count: Regex =
-        Regex::new(r#"function_calls_count\{\S*function="error_if_fn"\S*result="error"\S*\} 1"#)
-            .unwrap();
+    let error_count: Regex = Regex::new(
+        r#"function_calls_count(?:_total)?\{\S*function="error_if_fn"\S*result="error"\S*\} 1"#,
+    )
+    .unwrap();
     assert!(error_count.is_match(&metrics));
 }
 
@@ -148,7 +152,7 @@ fn caller_label() {
 
     let metrics = autometrics::encode_global_metrics().unwrap();
     let call_count: Regex = Regex::new(
-        r#"function_calls_count\{\S*caller="function_1"\S*function="function_2"\S*\} 1"#,
+        r#"function_calls_count(?:_total)?\{\S*caller="function_1"\S*function="function_2"\S*\} 1"#,
     )
     .unwrap();
     assert!(call_count.is_match(&metrics));

From 8635ad7a20cb21a5c65a46285abc7887c891c19e Mon Sep 17 00:00:00 2001
From: Evan Schwartz <3262610+emschwartz@users.noreply.github.com>
Date: Wed, 17 May 2023 15:01:39 +0200
Subject: [PATCH 07/16] Don't use regexes in tests (because different libraries
 order labels differently)

---
 autometrics/Cargo.toml                |   1 -
 autometrics/tests/integration_test.rs | 137 +++++++++++++++-----------
 autometrics/tests/objectives_test.rs  |  53 ++++++----
 3 files changed, 111 insertions(+), 80 deletions(-)

diff --git a/autometrics/Cargo.toml b/autometrics/Cargo.toml
index b903a55e..f6c8f67b 100644
--- a/autometrics/Cargo.toml
+++ b/autometrics/Cargo.toml
@@ -50,7 +50,6 @@ prometheus-client = { version = "0.21.1", optional = true }
 
 [dev-dependencies]
 axum = { version = "0.6", features = ["tokio"] }
-regex = "1.7"
 http = "0.2"
 tokio = { version = "1", features = ["full"] }
 trybuild = "1.0"
diff --git a/autometrics/tests/integration_test.rs b/autometrics/tests/integration_test.rs
index 89288362..611f45ea 100644
--- a/autometrics/tests/integration_test.rs
+++ b/autometrics/tests/integration_test.rs
@@ -1,7 +1,6 @@
+#![cfg(feature = "prometheus-exporter")]
 use autometrics::autometrics;
-use regex::Regex;
 
-#[cfg(feature = "prometheus-exporter")]
 #[test]
 fn single_function() {
     let _ = autometrics::global_metrics_exporter();
@@ -16,19 +15,21 @@ fn single_function() {
 
     let metrics = autometrics::encode_global_metrics().unwrap();
     println!("{}", metrics);
-    let call_count_metric: Regex = Regex::new(
-        r#"function_calls_count(?:_total)?\{\S*function="hello_world"\S*module="integration_test"\S*\} 2"#,
-    )
-    .unwrap();
-    let duration_metric: Regex = Regex::new(
-        r#"function_calls_duration_bucket\{\S*function="hello_world"\S*module="integration_test"\S*\}"#,
-    )
-    .unwrap();
-    assert!(call_count_metric.is_match(&metrics));
-    assert!(duration_metric.is_match(&metrics));
+    assert!(metrics.lines().any(|line| {
+        (line.starts_with("function_calls_count{")
+            || line.starts_with("function_calls_count_total{"))
+            && line.contains(r#"function="hello_world""#)
+            && line.contains(r#"module="integration_test""#)
+            && line.ends_with("} 2")
+    }));
+    assert!(metrics
+        .lines()
+        .any(|line| line.starts_with("function_calls_duration_bucket{")
+            && line.contains(r#"function="hello_world""#)
+            && line.contains(r#"module="integration_test""#)
+            && line.ends_with("} 2")));
 }
 
-#[cfg(feature = "prometheus-exporter")]
 #[test]
 fn impl_block() {
     let _ = autometrics::global_metrics_exporter();
@@ -50,21 +51,32 @@ fn impl_block() {
     Foo.test_method();
 
     let metrics = autometrics::encode_global_metrics().unwrap();
-    let test_fn_count: Regex =
-        Regex::new(r#"function_calls_count(?:_total)?\{\S*function="test_fn"\S*\} 1"#).unwrap();
-    let test_method_count: Regex =
-        Regex::new(r#"function_calls_count(?:_total)?\{\S*function="test_method"\S*\} 1"#).unwrap();
-    let test_fn_duration: Regex =
-        Regex::new(r#"function_calls_duration_bucket\{\S*function="test_fn"\S*\}"#).unwrap();
-    let test_method_duration: Regex =
-        Regex::new(r#"function_calls_duration_bucket\{\S*function="test_method"\S*\}"#).unwrap();
-    assert!(test_fn_count.is_match(&metrics));
-    assert!(test_method_count.is_match(&metrics));
-    assert!(test_fn_duration.is_match(&metrics));
-    assert!(test_method_duration.is_match(&metrics));
+    println!("{}", metrics);
+    assert!(metrics.lines().any(|line| {
+        (line.starts_with("function_calls_count{")
+            || line.starts_with("function_calls_count_total{"))
+            && line.contains(r#"function="test_fn""#)
+            && line.ends_with("} 1")
+    }));
+    assert!(metrics
+        .lines()
+        .any(|line| line.starts_with("function_calls_duration_bucket{")
+            && line.contains(r#"function="test_fn""#)
+            && line.ends_with("} 1")));
+
+    assert!(metrics.lines().any(|line| {
+        (line.starts_with("function_calls_count{")
+            || line.starts_with("function_calls_count_total{"))
+            && line.contains(r#"function="test_method""#)
+            && line.ends_with("} 1")
+    }));
+    assert!(metrics
+        .lines()
+        .any(|line| line.starts_with("function_calls_duration_bucket{")
+            && line.contains(r#"function="test_method""#)
+            && line.ends_with("} 1")));
 }
 
-#[cfg(feature = "prometheus-exporter")]
 #[test]
 fn result() {
     let _ = autometrics::global_metrics_exporter();
@@ -83,19 +95,23 @@ fn result() {
     result_fn(false).ok();
 
     let metrics = autometrics::encode_global_metrics().unwrap();
-    let error_count: Regex = Regex::new(
-        r#"function_calls_count(?:_total)?\{\S*function="result_fn"\S*result="error"\S*\} 2"#,
-    )
-    .unwrap();
-    assert!(error_count.is_match(&metrics));
-    let ok_count: Regex = Regex::new(
-        r#"function_calls_count(?:_total)?\{\S*function="result_fn"\S*result="ok"\S*\} 1"#,
-    )
-    .unwrap();
-    assert!(ok_count.is_match(&metrics));
+    println!("{}", metrics);
+    assert!(metrics
+        .lines()
+        .any(|line| (line.starts_with("function_calls_count{")
+            || line.starts_with("function_calls_count_total{"))
+            && line.contains(r#"function="result_fn""#)
+            && line.contains(r#"result="error""#)
+            && line.ends_with("} 2")));
+    assert!(metrics
+        .lines()
+        .any(|line| (line.starts_with("function_calls_count{")
+            || line.starts_with("function_calls_count_total{"))
+            && line.contains(r#"function="result_fn""#)
+            && line.contains(r#"result="ok""#)
+            && line.ends_with("} 1")));
 }
 
-#[cfg(feature = "prometheus-exporter")]
 #[test]
 fn ok_if() {
     let _ = autometrics::global_metrics_exporter();
@@ -108,14 +124,15 @@ fn ok_if() {
     ok_if_fn();
 
     let metrics = autometrics::encode_global_metrics().unwrap();
-    let error_count: Regex = Regex::new(
-        r#"function_calls_count(?:_total)?\{\S*function="ok_if_fn"\S*result="error"\S*\} 1"#,
-    )
-    .unwrap();
-    assert!(error_count.is_match(&metrics));
+    assert!(metrics.lines().any(|line| {
+        (line.starts_with("function_calls_count{")
+            || line.starts_with("function_calls_count_total{"))
+            && line.contains(r#"function="ok_if_fn""#)
+            && line.contains(r#"result="error""#)
+            && line.ends_with("} 1")
+    }));
 }
 
-#[cfg(feature = "prometheus-exporter")]
 #[test]
 fn error_if() {
     let _ = autometrics::global_metrics_exporter();
@@ -128,14 +145,15 @@ fn error_if() {
     error_if_fn();
 
     let metrics = autometrics::encode_global_metrics().unwrap();
-    let error_count: Regex = Regex::new(
-        r#"function_calls_count(?:_total)?\{\S*function="error_if_fn"\S*result="error"\S*\} 1"#,
-    )
-    .unwrap();
-    assert!(error_count.is_match(&metrics));
+    assert!(metrics.lines().any(|line| {
+        (line.starts_with("function_calls_count{")
+            || line.starts_with("function_calls_count_total{"))
+            && line.contains(r#"function="error_if_fn""#)
+            && line.contains(r#"result="error""#)
+            && line.ends_with("} 1")
+    }));
 }
 
-#[cfg(feature = "prometheus-exporter")]
 #[test]
 fn caller_label() {
     let _ = autometrics::global_metrics_exporter();
@@ -151,14 +169,15 @@ fn caller_label() {
     function_1();
 
     let metrics = autometrics::encode_global_metrics().unwrap();
-    let call_count: Regex = Regex::new(
-        r#"function_calls_count(?:_total)?\{\S*caller="function_1"\S*function="function_2"\S*\} 1"#,
-    )
-    .unwrap();
-    assert!(call_count.is_match(&metrics));
+    assert!(metrics.lines().any(|line| {
+        (line.starts_with("function_calls_count{")
+            || line.starts_with("function_calls_count_total{"))
+            && line.contains(r#"caller="function_1""#)
+            && line.contains(r#"function="function_2""#)
+            && line.ends_with("} 1")
+    }));
 }
 
-#[cfg(feature = "prometheus-exporter")]
 #[test]
 fn build_info() {
     let _ = autometrics::global_metrics_exporter();
@@ -170,7 +189,9 @@ fn build_info() {
     function_just_to_initialize_build_info();
 
     let metrics = autometrics::encode_global_metrics().unwrap();
-    let build_info: Regex =
-        Regex::new(r#"build_info\{branch="",commit="",version="\S+"\} 1"#).unwrap();
-    assert!(build_info.is_match(&metrics));
+    assert!(metrics.lines().any(|line| line.starts_with("build_info{")
+        && line.contains(r#"branch="""#)
+        && line.contains(r#"commit="""#)
+        && line.contains(&format!("version=\"{}\"", env!("CARGO_PKG_VERSION")))
+        && line.ends_with("} 1")));
 }
diff --git a/autometrics/tests/objectives_test.rs b/autometrics/tests/objectives_test.rs
index 518356e3..5a5ecbd3 100644
--- a/autometrics/tests/objectives_test.rs
+++ b/autometrics/tests/objectives_test.rs
@@ -1,5 +1,4 @@
 use autometrics::{autometrics, objectives::*};
-use regex::Regex;
 
 #[cfg(feature = "prometheus-exporter")]
 #[test]
@@ -17,11 +16,14 @@ fn success_rate() {
     success_rate_fn();
 
     let metrics = autometrics::encode_global_metrics().unwrap();
-    let call_count_metric: Regex = Regex::new(
-        r#"function_calls_count\{\S*function="success_rate_fn"\S*objective_name="test",objective_percentile="99"\S*\} 2"#,
-    )
-    .unwrap();
-    assert!(call_count_metric.is_match(&metrics));
+    assert!(metrics
+        .lines()
+        .any(|line| (line.starts_with("function_calls_count{")
+            || line.starts_with("function_calls_count_total{"))
+            && line.contains(r#"function="success_rate_fn""#)
+            && line.contains(r#"objective_name="test""#)
+            && line.contains(r#"objective_percentile="99""#)
+            && line.ends_with("} 2")));
 }
 
 #[cfg(feature = "prometheus-exporter")]
@@ -41,11 +43,14 @@ fn latency() {
     latency_fn();
 
     let metrics = autometrics::encode_global_metrics().unwrap();
-    let duration_metric: Regex = Regex::new(
-        r#"function_calls_duration_bucket\{\S*function="latency_fn"\S*objective_latency_threshold="0.1",objective_name="test",objective_percentile="99.9"\S*\} 2"#,
-    )
-    .unwrap();
-    assert!(duration_metric.is_match(&metrics));
+    assert!(metrics.lines().any(|line| {
+        line.starts_with("function_calls_duration_bucket{")
+            && line.contains(r#"function="latency_fn""#)
+            && line.contains(r#"objective_latency_threshold="0.1""#)
+            && line.contains(r#"objective_name="test""#)
+            && line.contains(r#"objective_percentile="99.9""#)
+            && line.ends_with("} 2")
+    }));
 }
 
 #[cfg(feature = "prometheus-exporter")]
@@ -66,14 +71,20 @@ fn combined_objective() {
     combined_objective_fn();
 
     let metrics = autometrics::encode_global_metrics().unwrap();
-    let call_count_metric: Regex = Regex::new(
-        r#"function_calls_count\{\S*function="combined_objective_fn"\S*objective_name="test",objective_percentile="99"\S*\} 2"#,
-    )
-    .unwrap();
-    let duration_metric: Regex = Regex::new(
-        r#"function_calls_duration_bucket\{\S*function="combined_objective_fn"\S*objective_latency_threshold="0.1",objective_name="test",objective_percentile="99.9"\S*\} 2"#,
-    )
-    .unwrap();
-    assert!(call_count_metric.is_match(&metrics));
-    assert!(duration_metric.is_match(&metrics));
+    assert!(metrics.lines().any(|line| {
+        (line.starts_with("function_calls_count{")
+            || line.starts_with("function_calls_count_total{"))
+            && line.contains(r#"function="combined_objective_fn""#)
+            && line.contains(r#"objective_name="test""#)
+            && line.contains(r#"objective_percentile="99""#)
+            && line.ends_with("} 2")
+    }));
+    assert!(metrics.lines().any(|line| {
+        line.starts_with("function_calls_duration_bucket{")
+            && line.contains(r#"function="combined_objective_fn""#)
+            && line.contains(r#"objective_latency_threshold="0.1""#)
+            && line.contains(r#"objective_name="test""#)
+            && line.contains(r#"objective_percentile="99.9""#)
+            && line.ends_with("} 2")
+    }));
 }

From 81306573f680abbcbd570e9c2210b94f6ca43c55 Mon Sep 17 00:00:00 2001
From: Evan Schwartz <3262610+emschwartz@users.noreply.github.com>
Date: Wed, 17 May 2023 15:24:22 +0200
Subject: [PATCH 08/16] Make once_cell a required dependency

---
 autometrics/Cargo.toml                   |  9 ++--
 autometrics/src/tracker/opentelemetry.rs | 54 ++++++++++++++----------
 autometrics/src/tracker/prometheus.rs    |  3 +-
 3 files changed, 36 insertions(+), 30 deletions(-)

diff --git a/autometrics/Cargo.toml b/autometrics/Cargo.toml
index f6c8f67b..d56935ca 100644
--- a/autometrics/Cargo.toml
+++ b/autometrics/Cargo.toml
@@ -16,11 +16,10 @@ readme = "README.md"
 default = ["opentelemetry"]
 metrics = ["dep:metrics"]
 opentelemetry = ["opentelemetry_api"]
-prometheus = ["dep:prometheus", "once_cell"]
-prometheus-client = ["dep:prometheus-client", "once_cell"]
+prometheus = ["dep:prometheus"]
+prometheus-client = ["dep:prometheus-client"]
 prometheus-exporter = [
   "metrics-exporter-prometheus",
-  "once_cell",
   "opentelemetry-prometheus",
   "opentelemetry_sdk",
   "dep:prometheus"
@@ -30,7 +29,8 @@ custom-objective-latency = []
 
 [dependencies]
 autometrics-macros = { workspace = true }
-spez = { version = "0.1.2" }
+spez = "0.1.2"
+once_cell = "1.17"
 
 # Used for opentelemetry feature
 opentelemetry_api = { version = "0.18", default-features = false, features = ["metrics"], optional = true }
@@ -40,7 +40,6 @@ metrics = { version = "0.21", default-features = false, optional = true }
 
 # Used for prometheus-exporter feature
 metrics-exporter-prometheus = { version = "0.12", default-features = false, optional = true }
-once_cell = { version = "1.17", optional = true }
 opentelemetry-prometheus = { version = "0.11", optional = true }
 opentelemetry_sdk = { version = "0.18", default-features = false, features = ["metrics"], optional = true }
 prometheus = { version = "0.13", default-features = false, optional = true }
diff --git a/autometrics/src/tracker/opentelemetry.rs b/autometrics/src/tracker/opentelemetry.rs
index 8a93c209..0378aea5 100644
--- a/autometrics/src/tracker/opentelemetry.rs
+++ b/autometrics/src/tracker/opentelemetry.rs
@@ -1,13 +1,33 @@
 use crate::labels::{BuildInfoLabels, CounterLabels, GaugeLabels, HistogramLabels, Label};
 use crate::{constants::*, tracker::TrackMetrics};
-use opentelemetry_api::{global, metrics::UpDownCounter, Context, KeyValue};
+use once_cell::sync::Lazy;
+use opentelemetry_api::metrics::{Counter, Histogram, UpDownCounter};
+use opentelemetry_api::{global, Context, KeyValue};
 use std::{sync::Once, time::Instant};
 
 static SET_BUILD_INFO: Once = Once::new();
+static CONCURRENCY_TRACKER: Lazy<UpDownCounter<i64>> = Lazy::new(|| {
+    global::meter("autometrics")
+        .i64_up_down_counter(GAUGE_NAME)
+        .with_description(GAUGE_DESCRIPTION)
+        .init()
+});
+static COUNTER: Lazy<Counter<f64>> = Lazy::new(|| {
+    global::meter("autometrics")
+        .f64_counter(COUNTER_NAME)
+        .with_description(COUNTER_DESCRIPTION)
+        .init()
+});
+static HISTOGRAM: Lazy<Histogram<f64>> = Lazy::new(|| {
+    global::meter("autometrics")
+        .f64_histogram(HISTOGRAM_NAME)
+        .with_description(HISTOGRAM_DESCRIPTION)
+        .init()
+});
 
 /// Tracks the number of function calls, concurrent calls, and latency
 pub struct OpenTelemetryTracker {
-    concurrency_tracker: Option<(UpDownCounter<i64>, Vec<KeyValue>)>,
+    gauge_labels: Option<Vec<KeyValue>>,
     start: Instant,
     context: Context,
 }
@@ -16,21 +36,17 @@ impl TrackMetrics for OpenTelemetryTracker {
     fn start(gauge_labels: Option<&GaugeLabels>) -> Self {
         let context = Context::current();
 
-        let concurrency_tracker = if let Some(gauge_labels) = gauge_labels {
+        let gauge_labels = if let Some(gauge_labels) = gauge_labels {
             let gauge_labels = to_key_values(gauge_labels.to_array());
             // Increase the number of concurrent requests
-            let concurrency_tracker = global::meter("")
-                .i64_up_down_counter(GAUGE_NAME)
-                .with_description(GAUGE_DESCRIPTION)
-                .init();
-            concurrency_tracker.add(&context, 1, &gauge_labels);
-            Some((concurrency_tracker, gauge_labels))
+            CONCURRENCY_TRACKER.add(&context, 1, &gauge_labels);
+            Some(gauge_labels)
         } else {
             None
         };
 
         Self {
-            concurrency_tracker,
+            gauge_labels,
             start: Instant::now(),
             context,
         }
@@ -40,31 +56,23 @@ impl TrackMetrics for OpenTelemetryTracker {
         let duration = self.start.elapsed().as_secs_f64();
 
         // Track the function calls
-        let counter = global::meter("")
-            .f64_counter(COUNTER_NAME)
-            .with_description(COUNTER_DESCRIPTION)
-            .init();
         let counter_labels = to_key_values(counter_labels.to_vec());
-        counter.add(&self.context, 1.0, &counter_labels);
+        COUNTER.add(&self.context, 1.0, &counter_labels);
 
         // Track the latency
-        let histogram = global::meter("")
-            .f64_histogram(HISTOGRAM_NAME)
-            .with_description(HISTOGRAM_DESCRIPTION)
-            .init();
         let histogram_labels = to_key_values(histogram_labels.to_vec());
-        histogram.record(&self.context, duration, &histogram_labels);
+        HISTOGRAM.record(&self.context, duration, &histogram_labels);
 
         // Decrease the number of concurrent requests
-        if let Some((concurrency_tracker, gauge_labels)) = self.concurrency_tracker {
-            concurrency_tracker.add(&self.context, -1, &gauge_labels);
+        if let Some(gauge_labels) = self.gauge_labels {
+            CONCURRENCY_TRACKER.add(&self.context, -1, &gauge_labels);
         }
     }
 
     fn set_build_info(build_info_labels: &BuildInfoLabels) {
         SET_BUILD_INFO.call_once(|| {
             let build_info_labels = to_key_values(build_info_labels.to_vec());
-            let build_info = global::meter("")
+            let build_info = global::meter("autometrics")
                 .f64_up_down_counter(BUILD_INFO_NAME)
                 .with_description(BUILD_INFO_DESCRIPTION)
                 .init();
diff --git a/autometrics/src/tracker/prometheus.rs b/autometrics/src/tracker/prometheus.rs
index 755867b0..b24be1ac 100644
--- a/autometrics/src/tracker/prometheus.rs
+++ b/autometrics/src/tracker/prometheus.rs
@@ -1,6 +1,5 @@
 use crate::labels::{BuildInfoLabels, CounterLabels, GaugeLabels, HistogramLabels, ResultLabel};
 use crate::{constants::*, tracker::TrackMetrics, HISTOGRAM_BUCKETS};
-use const_format::{formatcp, str_replace};
 use once_cell::sync::Lazy;
 use prometheus::core::{AtomicI64, GenericGauge};
 use prometheus::{
@@ -26,7 +25,7 @@ static COUNTER: Lazy<IntCounterVec> = Lazy::new(|| {
             OBJECTIVE_PERCENTILE_PROMETHEUS,
         ]
     )
-    .expect(formatcp!(
+    .expect(&format!(
         "Failed to register {COUNTER_NAME_PROMETHEUS} counter"
     ))
 });

From 49410dcd0211d9150ad897f752f16e58073436a7 Mon Sep 17 00:00:00 2001
From: Evan Schwartz <3262610+emschwartz@users.noreply.github.com>
Date: Wed, 17 May 2023 16:48:11 +0200
Subject: [PATCH 09/16] Rename concurrency tracker to gauge

---
 autometrics/src/tracker/opentelemetry.rs | 28 ++++++++++++------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/autometrics/src/tracker/opentelemetry.rs b/autometrics/src/tracker/opentelemetry.rs
index 0378aea5..a67d4c16 100644
--- a/autometrics/src/tracker/opentelemetry.rs
+++ b/autometrics/src/tracker/opentelemetry.rs
@@ -6,24 +6,24 @@ use opentelemetry_api::{global, Context, KeyValue};
 use std::{sync::Once, time::Instant};
 
 static SET_BUILD_INFO: Once = Once::new();
-static CONCURRENCY_TRACKER: Lazy<UpDownCounter<i64>> = Lazy::new(|| {
-    global::meter("autometrics")
-        .i64_up_down_counter(GAUGE_NAME)
-        .with_description(GAUGE_DESCRIPTION)
-        .init()
-});
-static COUNTER: Lazy<Counter<f64>> = Lazy::new(|| {
-    global::meter("autometrics")
-        .f64_counter(COUNTER_NAME)
+static COUNTER: Lazy<Counter<u64>> = Lazy::new(|| {
+    global::meter("")
+        .u64_counter(COUNTER_NAME)
         .with_description(COUNTER_DESCRIPTION)
         .init()
 });
 static HISTOGRAM: Lazy<Histogram<f64>> = Lazy::new(|| {
-    global::meter("autometrics")
+    global::meter("")
         .f64_histogram(HISTOGRAM_NAME)
         .with_description(HISTOGRAM_DESCRIPTION)
         .init()
 });
+static GAUGE: Lazy<UpDownCounter<i64>> = Lazy::new(|| {
+    global::meter("")
+        .i64_up_down_counter(GAUGE_NAME)
+        .with_description(GAUGE_DESCRIPTION)
+        .init()
+});
 
 /// Tracks the number of function calls, concurrent calls, and latency
 pub struct OpenTelemetryTracker {
@@ -39,7 +39,7 @@ impl TrackMetrics for OpenTelemetryTracker {
         let gauge_labels = if let Some(gauge_labels) = gauge_labels {
             let gauge_labels = to_key_values(gauge_labels.to_array());
             // Increase the number of concurrent requests
-            CONCURRENCY_TRACKER.add(&context, 1, &gauge_labels);
+            GAUGE.add(&context, 1, &gauge_labels);
             Some(gauge_labels)
         } else {
             None
@@ -57,7 +57,7 @@ impl TrackMetrics for OpenTelemetryTracker {
 
         // Track the function calls
         let counter_labels = to_key_values(counter_labels.to_vec());
-        COUNTER.add(&self.context, 1.0, &counter_labels);
+        COUNTER.add(&self.context, 1, &counter_labels);
 
         // Track the latency
         let histogram_labels = to_key_values(histogram_labels.to_vec());
@@ -65,14 +65,14 @@ impl TrackMetrics for OpenTelemetryTracker {
 
         // Decrease the number of concurrent requests
         if let Some(gauge_labels) = self.gauge_labels {
-            CONCURRENCY_TRACKER.add(&self.context, -1, &gauge_labels);
+            GAUGE.add(&self.context, -1, &gauge_labels);
         }
     }
 
     fn set_build_info(build_info_labels: &BuildInfoLabels) {
         SET_BUILD_INFO.call_once(|| {
             let build_info_labels = to_key_values(build_info_labels.to_vec());
-            let build_info = global::meter("autometrics")
+            let build_info = global::meter("")
                 .f64_up_down_counter(BUILD_INFO_NAME)
                 .with_description(BUILD_INFO_DESCRIPTION)
                 .init();

From ecfe52fcd771362e492b2cb82cbbf60374f071f1 Mon Sep 17 00:00:00 2001
From: Evan Schwartz <3262610+emschwartz@users.noreply.github.com>
Date: Fri, 19 May 2023 10:54:11 +0200
Subject: [PATCH 10/16] Move PROMETHEUS_CLIENT_REGISTRY to integrations module

---
 autometrics/src/lib.rs                 | 9 +++++++--
 autometrics/src/prometheus_exporter.rs | 2 +-
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/autometrics/src/lib.rs b/autometrics/src/lib.rs
index c09a70a1..31aa1be6 100644
--- a/autometrics/src/lib.rs
+++ b/autometrics/src/lib.rs
@@ -186,8 +186,13 @@ pub use autometrics_macros::ResultLabels;
 #[cfg(feature = "prometheus-exporter")]
 pub use self::prometheus_exporter::*;
 
-#[cfg(feature = "prometheus-client")]
-pub use self::tracker::prometheus_client::PROMETHEUS_CLIENT_REGISTRY;
+/// Functionality specific to the libraries used to collect metrics
+pub mod integrations {
+    #[cfg(feature = "prometheus-client")]
+    pub mod prometheus_client {
+        pub use crate::tracker::prometheus_client::PROMETHEUS_CLIENT_REGISTRY;
+    }
+}
 
 /// We use the histogram buckets recommended by the OpenTelemetry specification
 /// https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk.md#explicit-bucket-histogram-aggregation
diff --git a/autometrics/src/prometheus_exporter.rs b/autometrics/src/prometheus_exporter.rs
index 4d2ecfc5..e34b938f 100644
--- a/autometrics/src/prometheus_exporter.rs
+++ b/autometrics/src/prometheus_exporter.rs
@@ -35,7 +35,7 @@ impl GlobalPrometheus {
             output.push('\n');
             prometheus_client::encoding::text::encode(
                 &mut output,
-                &crate::PROMETHEUS_CLIENT_REGISTRY,
+                &crate::tracker::prometheus_client::PROMETHEUS_CLIENT_REGISTRY,
             )
             .map_err(|err| {
                 Error::Msg(format!(

From e311510774f7eeef3b88f37c31b2e17183677ff5 Mon Sep 17 00:00:00 2001
From: Evan Schwartz <3262610+emschwartz@users.noreply.github.com>
Date: Fri, 19 May 2023 16:48:46 +0200
Subject: [PATCH 11/16] Run all the other tests first

---
 .github/workflows/ci.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 946345fe..8ddd5f72 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -22,10 +22,12 @@ jobs:
       - run: cargo build --features=custom-objective-percentile,custom-objective-latency
 
       # Run the tests with each of the different metrics libraries
-      - run: cargo test --features=prometheus-exporter
       - run: cargo test --no-default-features --features=prometheus-exporter,metrics --tests
       - run: cargo test --no-default-features --features=prometheus-exporter,prometheus --tests
       - run: cargo test --no-default-features --features=prometheus-exporter,prometheus-client --tests
+      - run: cargo test --no-default-features --features=prometheus-exporter,opentelemetry --tests
+
+      - run: cargo test --features=prometheus-exporter
 
       # Compile the examples
       - run: cargo build --package example-axum

From ad830c304d1c36f314a093a416b286f8622a6953 Mon Sep 17 00:00:00 2001
From: Evan Schwartz <3262610+emschwartz@users.noreply.github.com>
Date: Fri, 19 May 2023 17:04:55 +0200
Subject: [PATCH 12/16] Run the tests in the same order

---
 .github/workflows/ci.yml | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 8ddd5f72..946345fe 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -22,12 +22,10 @@ jobs:
       - run: cargo build --features=custom-objective-percentile,custom-objective-latency
 
       # Run the tests with each of the different metrics libraries
+      - run: cargo test --features=prometheus-exporter
       - run: cargo test --no-default-features --features=prometheus-exporter,metrics --tests
       - run: cargo test --no-default-features --features=prometheus-exporter,prometheus --tests
       - run: cargo test --no-default-features --features=prometheus-exporter,prometheus-client --tests
-      - run: cargo test --no-default-features --features=prometheus-exporter,opentelemetry --tests
-
-      - run: cargo test --features=prometheus-exporter
 
       # Compile the examples
       - run: cargo build --package example-axum

From 4406f0805931979b89325a4e24db0c626f4c98a9 Mon Sep 17 00:00:00 2001
From: Evan Schwartz <3262610+emschwartz@users.noreply.github.com>
Date: Fri, 19 May 2023 17:05:18 +0200
Subject: [PATCH 13/16] The prometheus-exporter feature needs to depend on the
 prometheus feature (for now)

---
 autometrics/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/autometrics/Cargo.toml b/autometrics/Cargo.toml
index d56935ca..7d339703 100644
--- a/autometrics/Cargo.toml
+++ b/autometrics/Cargo.toml
@@ -22,7 +22,7 @@ prometheus-exporter = [
   "metrics-exporter-prometheus",
   "opentelemetry-prometheus",
   "opentelemetry_sdk",
-  "dep:prometheus"
+  "prometheus"
 ]
 custom-objective-percentile = []
 custom-objective-latency = []

From 43bea12d2f4bce64a930b3c5b8240200fd7fff2a Mon Sep 17 00:00:00 2001
From: Evan Schwartz <3262610+emschwartz@users.noreply.github.com>
Date: Fri, 19 May 2023 17:13:08 +0200
Subject: [PATCH 14/16] Rename export to just REGISTRY

---
 autometrics/src/lib.rs                       | 2 +-
 autometrics/src/prometheus_exporter.rs       | 2 +-
 autometrics/src/tracker/prometheus_client.rs | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/autometrics/src/lib.rs b/autometrics/src/lib.rs
index 31aa1be6..cf1571cf 100644
--- a/autometrics/src/lib.rs
+++ b/autometrics/src/lib.rs
@@ -190,7 +190,7 @@ pub use self::prometheus_exporter::*;
 pub mod integrations {
     #[cfg(feature = "prometheus-client")]
     pub mod prometheus_client {
-        pub use crate::tracker::prometheus_client::PROMETHEUS_CLIENT_REGISTRY;
+        pub use crate::tracker::prometheus_client::REGISTRY;
     }
 }
 
diff --git a/autometrics/src/prometheus_exporter.rs b/autometrics/src/prometheus_exporter.rs
index e34b938f..8129d6fe 100644
--- a/autometrics/src/prometheus_exporter.rs
+++ b/autometrics/src/prometheus_exporter.rs
@@ -35,7 +35,7 @@ impl GlobalPrometheus {
             output.push('\n');
             prometheus_client::encoding::text::encode(
                 &mut output,
-                &crate::tracker::prometheus_client::PROMETHEUS_CLIENT_REGISTRY,
+                &crate::tracker::prometheus_client::REGISTRY,
             )
             .map_err(|err| {
                 Error::Msg(format!(
diff --git a/autometrics/src/tracker/prometheus_client.rs b/autometrics/src/tracker/prometheus_client.rs
index 3e83485e..5b12cfeb 100644
--- a/autometrics/src/tracker/prometheus_client.rs
+++ b/autometrics/src/tracker/prometheus_client.rs
@@ -44,7 +44,7 @@ static REGISTRY_AND_METRICS: Lazy<(Registry, Metrics)> = Lazy::new(|| {
     )
 });
 /// The [`Registry`] used to collect metrics when the `prometheus-client` feature is enabled
-pub static PROMETHEUS_CLIENT_REGISTRY: Lazy<&Registry> = Lazy::new(|| &REGISTRY_AND_METRICS.0);
+pub static REGISTRY: Lazy<&Registry> = Lazy::new(|| &REGISTRY_AND_METRICS.0);
 
 struct Metrics {
     counter: Family<CounterLabels, Counter>,

From 36f65e263a296920d8ea5863b780a5c578ae5284 Mon Sep 17 00:00:00 2001
From: Evan Schwartz <3262610+emschwartz@users.noreply.github.com>
Date: Fri, 19 May 2023 17:29:27 +0200
Subject: [PATCH 15/16] Mention prometheus-client in readme and changelog

---
 CHANGELOG.md          | 1 +
 README.md             | 4 ++--
 autometrics/README.md | 2 +-
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 31a84692..75d07ef0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - `ResultLabels` derive macro allows to specify on an enum whether variants should
   always be "ok", or "error" for the success rate metrics of functions using them. (#61)
+- Support the official `prometheus-client` crate for producing metrics
 
 ### Changed
 
diff --git a/README.md b/README.md
index 725bd2a5..3d08ede4 100644
--- a/README.md
+++ b/README.md
@@ -54,7 +54,7 @@ https://github.com/autometrics-dev/autometrics-rs/assets/3262610/966ed140-1d6c-4
 - [🔍 Identify commits](https://docs.rs/autometrics/latest/autometrics/#identifying-commits-that-introduced-problems) that introduced errors or increased latency
 - [🚨 Define alerts](https://docs.rs/autometrics/latest/autometrics/objectives/index.html) using SLO best practices directly in your source code
 - [📊 Grafana dashboards](https://github.com/autometrics-dev#5-configuring-prometheus) work out of the box to visualize the performance of instrumented functions & SLOs
-- [⚙️ Configurable](https://docs.rs/autometrics/latest/autometrics/#metrics-libraries) metric collection library ([`opentelemetry`](https://crates.io/crates/opentelemetry), [`prometheus`](https://crates.io/crates/prometheus), or [`metrics`](https://crates.io/crates/metrics))
+- [⚙️ Configurable](https://docs.rs/autometrics/latest/autometrics/#metrics-libraries) metric collection library ([`opentelemetry`](https://crates.io/crates/opentelemetry), [`prometheus`](https://crates.io/crates/prometheus), [`prometheus-client`](https://crates.io/crates/prometheus-client) or [`metrics`](https://crates.io/crates/metrics))
 - ⚡ Minimal runtime overhead
 
 See [Why Autometrics?](https://github.com/autometrics-dev#4-why-autometrics) for more details on the ideas behind autometrics.
@@ -156,7 +156,7 @@ See [Why Autometrics?](https://github.com/autometrics-dev#4-why-autometrics) for
 
       <br />
 
-      [Configure `autometrics`](https://docs.rs/autometrics/latest/autometrics/#metrics-libraries) to use the same underlying metrics library you use with the appropriate feature flag: `opentelemetry`, `prometheus`, or `metrics`.
+      [Configure `autometrics`](https://docs.rs/autometrics/latest/autometrics/#metrics-libraries) to use the same underlying metrics library you use with the appropriate feature flag: `opentelemetry`, `prometheus`, `prometheus-client`, or `metrics`.
 
       ```toml
       [dependencies]
diff --git a/autometrics/README.md b/autometrics/README.md
index 33fd5683..404bd336 100644
--- a/autometrics/README.md
+++ b/autometrics/README.md
@@ -53,7 +53,7 @@ pub async fn main() {
 - [🔍 Identify commits](#identifying-commits-that-introduced-problems) that introduced errors or increased latency
 - [🚨 Define alerts](https://docs.rs/autometrics/latest/autometrics/objectives/index.html) using SLO best practices directly in your source code
 - [📊 Grafana dashboards](https://github.com/autometrics-dev#5-configuring-prometheus) work out of the box to visualize the performance of instrumented functions & SLOs
-- [⚙️ Configurable](#metrics-libraries) metric collection library ([`opentelemetry`](https://crates.io/crates/opentelemetry), [`prometheus`](https://crates.io/crates/prometheus), or [`metrics`](https://crates.io/crates/metrics))
+- [⚙️ Configurable](#metrics-libraries) metric collection library ([`opentelemetry`](https://crates.io/crates/opentelemetry), [`prometheus`](https://crates.io/crates/prometheus), [`prometheus-client`](https://crates.io/crates/prometheus-client) or [`metrics`](https://crates.io/crates/metrics))
 - ⚡ Minimal runtime overhead
 
 See [Why Autometrics?](https://github.com/autometrics-dev#4-why-autometrics) for more details on the ideas behind autometrics.

From 8f263f8e1c217ee94fff0a662bd218262e070638 Mon Sep 17 00:00:00 2001
From: Evan Schwartz <3262610+emschwartz@users.noreply.github.com>
Date: Tue, 23 May 2023 14:43:57 +0200
Subject: [PATCH 16/16] Remove print statements

---
 autometrics/tests/integration_test.rs | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/autometrics/tests/integration_test.rs b/autometrics/tests/integration_test.rs
index 611f45ea..3ae27884 100644
--- a/autometrics/tests/integration_test.rs
+++ b/autometrics/tests/integration_test.rs
@@ -14,7 +14,6 @@ fn single_function() {
     hello_world();
 
     let metrics = autometrics::encode_global_metrics().unwrap();
-    println!("{}", metrics);
     assert!(metrics.lines().any(|line| {
         (line.starts_with("function_calls_count{")
             || line.starts_with("function_calls_count_total{"))
@@ -51,7 +50,6 @@ fn impl_block() {
     Foo.test_method();
 
     let metrics = autometrics::encode_global_metrics().unwrap();
-    println!("{}", metrics);
     assert!(metrics.lines().any(|line| {
         (line.starts_with("function_calls_count{")
             || line.starts_with("function_calls_count_total{"))
@@ -95,7 +93,6 @@ fn result() {
     result_fn(false).ok();
 
     let metrics = autometrics::encode_global_metrics().unwrap();
-    println!("{}", metrics);
     assert!(metrics
         .lines()
         .any(|line| (line.starts_with("function_calls_count{")