diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f8d578d8..07a7ef29 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -18,18 +18,21 @@ jobs:
       - uses: Swatinem/rust-cache@v2
 
       # Lint
-      - name: Run Clippy
-        # GitHub hosted runners using the latest stable version of Rust have Clippy pre-installed.
-        run: cargo clippy --all-targets --features=prometheus-exporter,opentelemetry,metrics,prometheus
+      # Note: GitHub hosted runners using the latest stable version of Rust have Clippy pre-installed.
+      - run: cargo clippy --features=metrics,prometheus-exporter
+      - run: cargo clippy --features=prometheus
+      - run: cargo clippy --features=prometheus-client
+      - run: cargo clippy --features=opentelemetry
 
       # 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/CHANGELOG.md b/CHANGELOG.md
index d96d63dc..2322818a 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 2136c485..0996e933 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/Cargo.toml b/autometrics/Cargo.toml
index 851a0c14..19090642 100644
--- a/autometrics/Cargo.toml
+++ b/autometrics/Cargo.toml
@@ -16,10 +16,10 @@ readme = "README.md"
 default = ["opentelemetry"]
 metrics = ["dep:metrics"]
 opentelemetry = ["opentelemetry_api"]
-prometheus = ["const_format", "dep:prometheus", "once_cell"]
+prometheus = ["dep:prometheus"]
+prometheus-client = ["dep:prometheus-client"]
 prometheus-exporter = [
   "metrics-exporter-prometheus",
-  "once_cell",
   "opentelemetry-prometheus",
   "opentelemetry_sdk",
   "prometheus"
@@ -29,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.19.0", default-features = false, features = ["metrics"], optional = true }
@@ -39,17 +40,15 @@ 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.12.0", optional = true }
 opentelemetry_sdk = { version = "0.19", 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 }
 
 [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/README.md b/autometrics/README.md
index c539606b..e56b11d7 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.
diff --git a/autometrics/src/constants.rs b/autometrics/src/constants.rs
index 176fc23e..3311424d 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";
diff --git a/autometrics/src/labels.rs b/autometrics/src/labels.rs
index b27a2a3d..8462de0c 100644
--- a/autometrics/src/labels.rs
+++ b/autometrics/src/labels.rs
@@ -1,14 +1,20 @@
 use crate::{constants::*, objectives::*};
+#[cfg(feature = "prometheus-client")]
+use prometheus_client::encoding::{EncodeLabelSet, EncodeLabelValue, LabelValueEncoder};
 use std::ops::Deref;
 
 pub(crate) type Label = (&'static str, &'static str);
 pub 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,
     pub(crate) branch: &'static str,
+    pub(crate) commit: &'static str,
+    pub(crate) version: &'static str,
 }
 
 impl BuildInfoLabels {
@@ -30,12 +36,47 @@ 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,
+}
+
+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> {
+        match self {
+            ResultLabel::Ok => EncodeLabelValue::encode(&OK_KEY, encoder),
+            ResultLabel::Error => EncodeLabelValue::encode(&ERROR_KEY, encoder),
+        }
+    }
 }
 
 impl CounterLabels {
@@ -46,21 +87,33 @@ 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))
+                (Some(objective.name), Some(success_rate))
             } else {
-                None
+                (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, None)
         };
         Self {
             function,
             module,
             caller,
+            objective_name,
+            objective_percentile,
             result,
-            objective,
+            ok,
+            error,
         }
     }
 
@@ -70,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(objective_name) = self.objective_name {
+            labels.push((OBJECTIVE_NAME, objective_name));
         }
-        if let Some((name, percentile)) = &self.objective {
-            labels.push((OBJECTIVE_NAME, name));
-            labels.push((OBJECTIVE_PERCENTILE, percentile.as_str()));
+        if let Some(objective_percentile) = &self.objective_percentile {
+            labels.push((OBJECTIVE_PERCENTILE, objective_percentile.as_str()));
         }
 
         labels
@@ -86,39 +144,54 @@ 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: 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
@@ -126,6 +199,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,
@@ -235,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/lib.rs b/autometrics/src/lib.rs
index 434efa38..cf1571cf 100644
--- a/autometrics/src/lib.rs
+++ b/autometrics/src/lib.rs
@@ -186,9 +186,21 @@ pub use autometrics_macros::ResultLabels;
 #[cfg(feature = "prometheus-exporter")]
 pub use self::prometheus_exporter::*;
 
+/// 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::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(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 82d1d922..7b753fac 100644
--- a/autometrics/src/objectives.rs
+++ b/autometrics/src/objectives.rs
@@ -24,6 +24,9 @@
 //! }
 //! ```
 
+#[cfg(feature = "prometheus-client")]
+use prometheus_client::encoding::{EncodeLabelValue, LabelValueEncoder};
+
 /// A Service-Level Objective (SLO) for a function or group of functions.
 ///
 /// The objective should be given a descriptive name and can represent
@@ -119,6 +122,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%
@@ -152,7 +159,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
@@ -234,3 +252,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/prometheus_exporter.rs b/autometrics/src/prometheus_exporter.rs
index e725536b..d2ec76f5 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::tracker::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 e5211e3f..dd7c9ce8 100644
--- a/autometrics/src/tracker/mod.rs
+++ b/autometrics/src/tracker/mod.rs
@@ -6,19 +6,36 @@ mod metrics;
 mod opentelemetry;
 #[cfg(feature = "prometheus")]
 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/opentelemetry.rs b/autometrics/src/tracker/opentelemetry.rs
index 8a93c209..a67d4c16 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 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("")
+        .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 {
-    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))
+            GAUGE.add(&context, 1, &gauge_labels);
+            Some(gauge_labels)
         } else {
             None
         };
 
         Self {
-            concurrency_tracker,
+            gauge_labels,
             start: Instant::now(),
             context,
         }
@@ -40,24 +56,16 @@ 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, &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 {
+            GAUGE.add(&self.context, -1, &gauge_labels);
         }
     }
 
diff --git a/autometrics/src/tracker/prometheus.rs b/autometrics/src/tracker/prometheus.rs
index 77de384d..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};
+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::{
@@ -9,13 +8,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(|| {
@@ -33,7 +25,7 @@ static COUNTER: Lazy<IntCounterVec> = Lazy::new(|| {
             OBJECTIVE_PERCENTILE_PROMETHEUS,
         ]
     )
-    .expect(formatcp!(
+    .expect(&format!(
         "Failed to register {COUNTER_NAME_PROMETHEUS} counter"
     ))
 });
@@ -54,7 +46,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")
@@ -107,27 +99,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 {
-                        ""
-                    },
-                    if let Some((ERROR_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 => "",
                     },
+                    counter_labels.ok.unwrap_or_default(),
+                    counter_labels.error.unwrap_or_default(),
+                    counter_labels.objective_name.unwrap_or_default(),
                     counter_labels
-                        .objective
-                        .as_ref()
-                        .map(|obj| obj.0)
-                        .unwrap_or(""),
-                    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 +120,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
new file mode 100644
index 00000000..5b12cfeb
--- /dev/null
+++ b/autometrics/src/tracker/prometheus_client.rs
@@ -0,0 +1,103 @@
+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;
+use std::time::Instant;
+
+static REGISTRY_AND_METRICS: Lazy<(Registry, Metrics)> = Lazy::new(|| {
+    let mut registry = <Registry>::default();
+
+    let counter = Family::<CounterLabels, Counter>::default();
+    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_PROMETHEUS,
+        HISTOGRAM_DESCRIPTION,
+        histogram.clone(),
+    );
+
+    let gauge = Family::<GaugeLabels, Gauge>::default();
+    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());
+
+    (
+        registry,
+        Metrics {
+            counter,
+            histogram,
+            gauge,
+            build_info,
+        },
+    )
+});
+/// The [`Registry`] used to collect metrics when the `prometheus-client` feature is enabled
+pub static REGISTRY: Lazy<&Registry> = Lazy::new(|| &REGISTRY_AND_METRICS.0);
+
+struct Metrics {
+    counter: Family<CounterLabels, Counter>,
+    histogram: Family<HistogramLabels, Histogram>,
+    gauge: Family<GaugeLabels, Gauge>,
+    build_info: Family<BuildInfoLabels, Gauge>,
+}
+
+pub struct PrometheusClientTracker {
+    gauge_labels: Option<GaugeLabels>,
+    start_time: Instant,
+}
+
+impl TrackMetrics for PrometheusClientTracker {
+    fn set_build_info(build_info_labels: &BuildInfoLabels) {
+        REGISTRY_AND_METRICS
+            .1
+            .build_info
+            .get_or_create(&build_info_labels)
+            .set(1);
+    }
+
+    fn start(gauge_labels: Option<&GaugeLabels>) -> Self {
+        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) {
+        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();
+        }
+    }
+}
diff --git a/autometrics/tests/integration_test.rs b/autometrics/tests/integration_test.rs
index c78ecb3b..3ae27884 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();
@@ -15,20 +14,21 @@ fn single_function() {
     hello_world();
 
     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"#,
-    )
-    .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 +50,31 @@ fn impl_block() {
     Foo.test_method();
 
     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();
-    let test_method_count: Regex =
-        Regex::new(r#"function_calls_count\{\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));
+    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,17 +93,22 @@ 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();
-    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();
-    assert!(ok_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="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();
@@ -106,13 +121,15 @@ 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();
-    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();
@@ -125,13 +142,15 @@ 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();
-    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();
@@ -147,14 +166,15 @@ fn caller_label() {
     function_1();
 
     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"#,
-    )
-    .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();
@@ -166,7 +186,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")
+    }));
 }