diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 00000000..05caea0a
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,13 @@
+# http://editorconfig.org
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.rs]
+indent_size = 4
diff --git a/Cargo.toml b/Cargo.toml
index bed9f658..c026295b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,4 +6,5 @@ members = [
   "metrics-benchmark",
   "metrics-exporter-tcp",
   "metrics-exporter-prometheus",
+  "metrics-tracing-context",
 ]
diff --git a/metrics-exporter-prometheus/src/lib.rs b/metrics-exporter-prometheus/src/lib.rs
index e7435c1f..10b5b578 100644
--- a/metrics-exporter-prometheus/src/lib.rs
+++ b/metrics-exporter-prometheus/src/lib.rs
@@ -6,7 +6,7 @@ use hyper::{
     service::{make_service_fn, service_fn},
     {Body, Error as HyperError, Response, Server},
 };
-use metrics::{Identifier, Key, Label, Recorder, SetRecorderError};
+use metrics::{Key, Recorder, SetRecorderError};
 use metrics_util::{
     parse_quantiles, CompositeKey, Handle, Histogram, MetricKind, Quantile, Registry,
 };
@@ -494,73 +494,77 @@ impl PrometheusBuilder {
 }
 
 impl Recorder for PrometheusRecorder {
-    fn register_counter(&self, key: Key, description: Option<&'static str>) -> Identifier {
+    fn register_counter(&self, key: Key, description: Option<&'static str>) {
         self.add_description_if_missing(&key, description);
-        self.inner
-            .registry()
-            .get_or_create_identifier(CompositeKey::new(MetricKind::Counter, key), |_| {
-                Handle::counter()
-            })
+        self.inner.registry().op(
+            CompositeKey::new(MetricKind::Counter, key),
+            |_| {},
+            || Handle::counter(),
+        );
     }
 
-    fn register_gauge(&self, key: Key, description: Option<&'static str>) -> Identifier {
+    fn register_gauge(&self, key: Key, description: Option<&'static str>) {
         self.add_description_if_missing(&key, description);
-        self.inner
-            .registry()
-            .get_or_create_identifier(CompositeKey::new(MetricKind::Gauge, key), |_| {
-                Handle::gauge()
-            })
+        self.inner.registry().op(
+            CompositeKey::new(MetricKind::Gauge, key),
+            |_| {},
+            || Handle::gauge(),
+        );
     }
 
-    fn register_histogram(&self, key: Key, description: Option<&'static str>) -> Identifier {
+    fn register_histogram(&self, key: Key, description: Option<&'static str>) {
         self.add_description_if_missing(&key, description);
-        self.inner
-            .registry()
-            .get_or_create_identifier(CompositeKey::new(MetricKind::Histogram, key), |_| {
-                Handle::histogram()
-            })
+        self.inner.registry().op(
+            CompositeKey::new(MetricKind::Histogram, key),
+            |_| {},
+            || Handle::histogram(),
+        );
     }
 
-    fn increment_counter(&self, id: Identifier, value: u64) {
-        self.inner
-            .registry()
-            .with_handle(id, |h| h.increment_counter(value));
+    fn increment_counter(&self, key: Key, value: u64) {
+        self.inner.registry().op(
+            CompositeKey::new(MetricKind::Counter, key),
+            |h| h.increment_counter(value),
+            || Handle::counter(),
+        );
     }
 
-    fn update_gauge(&self, id: Identifier, value: f64) {
-        self.inner
-            .registry()
-            .with_handle(id, |h| h.update_gauge(value));
+    fn update_gauge(&self, key: Key, value: f64) {
+        self.inner.registry().op(
+            CompositeKey::new(MetricKind::Gauge, key),
+            |h| h.update_gauge(value),
+            || Handle::gauge(),
+        );
     }
 
-    fn record_histogram(&self, id: Identifier, value: u64) {
-        self.inner
-            .registry()
-            .with_handle(id, |h| h.record_histogram(value));
+    fn record_histogram(&self, key: Key, value: u64) {
+        self.inner.registry().op(
+            CompositeKey::new(MetricKind::Histogram, key),
+            |h| h.record_histogram(value),
+            || Handle::histogram(),
+        );
     }
 }
 
 fn key_to_parts(key: Key) -> (String, Vec<String>) {
-    let (name, labels) = key.into_parts();
+    let name = key.name();
+    let labels = key.labels();
     let sanitize = |c| c == '.' || c == '=' || c == '{' || c == '}' || c == '+' || c == '-';
     let name = name.replace(sanitize, "_");
     let labels = labels
-        .map(|labels| {
-            labels
-                .into_iter()
-                .map(Label::into_parts)
-                .map(|(k, v)| {
-                    format!(
-                        "{}=\"{}\"",
-                        k,
-                        v.replace("\\", "\\\\")
-                            .replace("\"", "\\\"")
-                            .replace("\n", "\\n")
-                    )
-                })
-                .collect()
+        .into_iter()
+        .map(|label| {
+            let k = label.key();
+            let v = label.value();
+            format!(
+                "{}=\"{}\"",
+                k,
+                v.replace("\\", "\\\\")
+                    .replace("\"", "\\\"")
+                    .replace("\n", "\\n")
+            )
         })
-        .unwrap_or_else(|| Vec::new());
+        .collect();
 
     (name, labels)
 }
diff --git a/metrics-exporter-tcp/src/lib.rs b/metrics-exporter-tcp/src/lib.rs
index eaadee40..c58fb3ca 100644
--- a/metrics-exporter-tcp/src/lib.rs
+++ b/metrics-exporter-tcp/src/lib.rs
@@ -53,8 +53,7 @@ use std::time::SystemTime;
 
 use bytes::Bytes;
 use crossbeam_channel::{bounded, unbounded, Receiver, Sender};
-use metrics::{Identifier, Key, Recorder, SetRecorderError};
-use metrics_util::Registry;
+use metrics::{Key, Recorder, SetRecorderError};
 use mio::{
     net::{TcpListener, TcpStream},
     Events, Interest, Poll, Token, Waker,
@@ -71,30 +70,12 @@ mod proto {
     include!(concat!(env!("OUT_DIR"), "/event.proto.rs"));
 }
 
-type TcpRegistry = Registry<CompositeKey, CompositeKey>;
-
-#[derive(Eq, PartialEq, Hash, Clone)]
-enum MetricKind {
-    Counter,
-    Gauge,
-    Histogram,
-}
-
 enum MetricValue {
     Counter(u64),
     Gauge(f64),
     Histogram(u64),
 }
 
-#[derive(Eq, PartialEq, Hash, Clone)]
-struct CompositeKey(MetricKind, Key);
-
-impl CompositeKey {
-    pub fn key(&self) -> &Key {
-        &self.1
-    }
-}
-
 /// Errors that could occur while installing a TCP recorder/exporter.
 #[derive(Debug)]
 pub enum Error {
@@ -119,8 +100,7 @@ impl From<SetRecorderError> for Error {
 
 /// A TCP recorder.
 pub struct TcpRecorder {
-    registry: Arc<TcpRegistry>,
-    tx: Sender<(Identifier, MetricValue)>,
+    tx: Sender<(Key, MetricValue)>,
     waker: Arc<Waker>,
 }
 
@@ -200,67 +180,48 @@ impl TcpBuilder {
         poll.registry()
             .register(&mut listener, LISTENER, Interest::READABLE)?;
 
-        let registry = Arc::new(Registry::new());
-
         let recorder = TcpRecorder {
-            registry: Arc::clone(&registry),
             tx,
             waker: Arc::clone(&waker),
         };
 
-        thread::spawn(move || run_transport(registry, poll, waker, listener, rx, buffer_size));
+        thread::spawn(move || run_transport(poll, waker, listener, rx, buffer_size));
         Ok(recorder)
     }
 }
 
 impl TcpRecorder {
-    fn register_metric(&self, kind: MetricKind, key: Key) -> Identifier {
-        let ckey = CompositeKey(kind, key);
-        self.registry.get_or_create_identifier(ckey, |k| k.clone())
-    }
-
-    fn push_metric(&self, id: Identifier, value: MetricValue) {
-        let id = match id {
-            Identifier::Invalid => return,
-            Identifier::Valid(_) => id,
-        };
-        let _ = self.tx.try_send((id, value));
+    fn push_metric(&self, key: Key, value: MetricValue) {
+        let _ = self.tx.try_send((key, value));
         let _ = self.waker.wake();
     }
 }
 
 impl Recorder for TcpRecorder {
-    fn register_counter(&self, key: Key, _description: Option<&'static str>) -> Identifier {
-        self.register_metric(MetricKind::Counter, key)
-    }
+    fn register_counter(&self, _key: Key, _description: Option<&'static str>) {}
 
-    fn register_gauge(&self, key: Key, _description: Option<&'static str>) -> Identifier {
-        self.register_metric(MetricKind::Gauge, key)
-    }
+    fn register_gauge(&self, _key: Key, _description: Option<&'static str>) {}
 
-    fn register_histogram(&self, key: Key, _description: Option<&'static str>) -> Identifier {
-        self.register_metric(MetricKind::Histogram, key)
-    }
+    fn register_histogram(&self, _key: Key, _description: Option<&'static str>) {}
 
-    fn increment_counter(&self, id: Identifier, value: u64) {
-        self.push_metric(id, MetricValue::Counter(value));
+    fn increment_counter(&self, key: Key, value: u64) {
+        self.push_metric(key, MetricValue::Counter(value));
     }
 
-    fn update_gauge(&self, id: Identifier, value: f64) {
-        self.push_metric(id, MetricValue::Gauge(value));
+    fn update_gauge(&self, key: Key, value: f64) {
+        self.push_metric(key, MetricValue::Gauge(value));
     }
 
-    fn record_histogram(&self, id: Identifier, value: u64) {
-        self.push_metric(id, MetricValue::Histogram(value));
+    fn record_histogram(&self, key: Key, value: u64) {
+        self.push_metric(key, MetricValue::Histogram(value));
     }
 }
 
 fn run_transport(
-    registry: Arc<TcpRegistry>,
     mut poll: Poll,
     waker: Arc<Waker>,
     listener: TcpListener,
-    rx: Receiver<(Identifier, MetricValue)>,
+    rx: Receiver<(Key, MetricValue)>,
     buffer_size: Option<usize>,
 ) {
     let buffer_limit = buffer_size.unwrap_or(std::usize::MAX);
@@ -309,10 +270,10 @@ fn run_transport(
                             // If our sender is dead, we can't do anything else, so just return.
                             Err(_) => return,
                         };
-                        match convert_metric_to_protobuf_encoded(&registry, msg.0, msg.1) {
-                            Some(Ok(pmsg)) => buffered_pmsgs.push_back(pmsg),
-                            Some(Err(e)) => error!(error = ?e, "error encoding metric"),
-                            None => error!(metric_id = ?msg.0, "unknown metric"),
+                        let (key, value) = msg;
+                        match convert_metric_to_protobuf_encoded(key, value) {
+                            Ok(pmsg) => buffered_pmsgs.push_back(pmsg),
+                            Err(e) => error!(error = ?e, "error encoding metric"),
                         }
                     }
                     drop(_mrxspan);
@@ -460,46 +421,31 @@ fn drive_connection(
     }
 }
 
-fn convert_metric_to_protobuf_encoded(
-    registry: &Arc<TcpRegistry>,
-    id: Identifier,
-    value: MetricValue,
-) -> Option<Result<Bytes, EncodeError>> {
-    let id = match id {
-        Identifier::Invalid => return None,
-        Identifier::Valid(_) => id,
+fn convert_metric_to_protobuf_encoded(key: Key, value: MetricValue) -> Result<Bytes, EncodeError> {
+    let name = key.name().to_string();
+    let labels = key
+        .labels()
+        .map(|label| (label.key().to_owned(), label.value().to_owned()))
+        .collect::<BTreeMap<_, _>>();
+    let mvalue = match value {
+        MetricValue::Counter(cv) => proto::metric::Value::Counter(proto::Counter { value: cv }),
+        MetricValue::Gauge(gv) => proto::metric::Value::Gauge(proto::Gauge { value: gv }),
+        MetricValue::Histogram(hv) => {
+            proto::metric::Value::Histogram(proto::Histogram { value: hv })
+        }
     };
-    registry.with_handle(id, |ckey| {
-        let name = ckey.key().name().to_string();
-        let labels = ckey
-            .key()
-            .labels()
-            .map(|labels| {
-                labels
-                    .map(|label| (label.key().to_string(), label.value().to_string()))
-                    .collect::<BTreeMap<_, _>>()
-            })
-            .unwrap_or_else(|| BTreeMap::new());
-        let mvalue = match value {
-            MetricValue::Counter(cv) => proto::metric::Value::Counter(proto::Counter { value: cv }),
-            MetricValue::Gauge(gv) => proto::metric::Value::Gauge(proto::Gauge { value: gv }),
-            MetricValue::Histogram(hv) => {
-                proto::metric::Value::Histogram(proto::Histogram { value: hv })
-            }
-        };
 
-        let now: prost_types::Timestamp = SystemTime::now().into();
-        let metric = proto::Metric {
-            name,
-            labels,
-            timestamp: Some(now),
-            value: Some(mvalue),
-        };
+    let now: prost_types::Timestamp = SystemTime::now().into();
+    let metric = proto::Metric {
+        name,
+        labels,
+        timestamp: Some(now),
+        value: Some(mvalue),
+    };
 
-        let mut buf = Vec::new();
-        metric.encode_length_delimited(&mut buf)?;
-        Ok(Bytes::from(buf))
-    })
+    let mut buf = Vec::new();
+    metric.encode_length_delimited(&mut buf)?;
+    Ok(Bytes::from(buf))
 }
 
 fn next(current: &mut Token) -> Token {
diff --git a/metrics-macros/src/lib.rs b/metrics-macros/src/lib.rs
index f9fcfd21..b3046ca9 100644
--- a/metrics-macros/src/lib.rs
+++ b/metrics-macros/src/lib.rs
@@ -7,6 +7,9 @@ use quote::{format_ident, quote, ToTokens};
 use syn::parse::{Error, Parse, ParseStream, Result};
 use syn::{parse_macro_input, Expr, LitStr, Token};
 
+#[cfg(test)]
+mod tests;
+
 enum Key {
     NotScoped(LitStr),
     Scoped(LitStr),
@@ -102,7 +105,7 @@ pub fn register_counter(input: TokenStream) -> TokenStream {
         labels,
     } = parse_macro_input!(input as Registration);
 
-    get_expanded_registration("counter", key, description, labels)
+    get_expanded_registration("counter", key, description, labels).into()
 }
 
 #[proc_macro_hack]
@@ -113,7 +116,7 @@ pub fn register_gauge(input: TokenStream) -> TokenStream {
         labels,
     } = parse_macro_input!(input as Registration);
 
-    get_expanded_registration("gauge", key, description, labels)
+    get_expanded_registration("gauge", key, description, labels).into()
 }
 
 #[proc_macro_hack]
@@ -124,7 +127,7 @@ pub fn register_histogram(input: TokenStream) -> TokenStream {
         labels,
     } = parse_macro_input!(input as Registration);
 
-    get_expanded_registration("histogram", key, description, labels)
+    get_expanded_registration("histogram", key, description, labels).into()
 }
 
 #[proc_macro_hack]
@@ -133,7 +136,7 @@ pub fn increment(input: TokenStream) -> TokenStream {
 
     let op_value = quote! { 1 };
 
-    get_expanded_callsite("counter", "increment", key, labels, op_value)
+    get_expanded_callsite("counter", "increment", key, labels, op_value).into()
 }
 
 #[proc_macro_hack]
@@ -144,7 +147,7 @@ pub fn counter(input: TokenStream) -> TokenStream {
         labels,
     } = parse_macro_input!(input as WithExpression);
 
-    get_expanded_callsite("counter", "increment", key, labels, op_value)
+    get_expanded_callsite("counter", "increment", key, labels, op_value).into()
 }
 
 #[proc_macro_hack]
@@ -155,7 +158,7 @@ pub fn gauge(input: TokenStream) -> TokenStream {
         labels,
     } = parse_macro_input!(input as WithExpression);
 
-    get_expanded_callsite("gauge", "update", key, labels, op_value)
+    get_expanded_callsite("gauge", "update", key, labels, op_value).into()
 }
 
 #[proc_macro_hack]
@@ -166,7 +169,7 @@ pub fn histogram(input: TokenStream) -> TokenStream {
         labels,
     } = parse_macro_input!(input as WithExpression);
 
-    get_expanded_callsite("histogram", "record", key, labels, op_value)
+    get_expanded_callsite("histogram", "record", key, labels, op_value).into()
 }
 
 fn get_expanded_registration(
@@ -174,7 +177,7 @@ fn get_expanded_registration(
     key: Key,
     description: Option<LitStr>,
     labels: Option<Labels>,
-) -> TokenStream {
+) -> proc_macro2::TokenStream {
     let register_ident = format_ident!("register_{}", metric_type);
     let key = key_to_quoted(key, labels);
 
@@ -183,16 +186,16 @@ fn get_expanded_registration(
         None => quote! { None },
     };
 
-    let expanded = quote! {
+    quote! {
         {
             // Only do this work if there's a recorder installed.
             if let Some(recorder) = metrics::try_recorder() {
-                recorder.#register_ident(#key, #description);
+                // Registrations are fairly rare, don't attempt to cache here
+                // and just use an owned ref.
+                recorder.#register_ident(metrics::Key::Owned(#key), #description);
             }
         }
-    };
-
-    TokenStream::from(expanded)
+    }
 }
 
 fn get_expanded_callsite<V>(
@@ -201,12 +204,10 @@ fn get_expanded_callsite<V>(
     key: Key,
     labels: Option<Labels>,
     op_values: V,
-) -> TokenStream
+) -> proc_macro2::TokenStream
 where
     V: ToTokens,
 {
-    let register_ident = format_ident!("register_{}", metric_type);
-    let op_ident = format_ident!("{}_{}", op_type, metric_type);
     let use_fast_path = can_use_fast_path(&labels);
     let key = key_to_quoted(key, labels);
 
@@ -218,21 +219,20 @@ where
         quote! { #op_values }
     };
 
-    let expanded = if use_fast_path {
-        // We're on the fast path here, so we'll end up registering with the recorder
-        // and statically caching the identifier for our metric to speed up any future
-        // increment operations.
+    let op_ident = format_ident!("{}_{}", op_type, metric_type);
+
+    if use_fast_path {
+        // We're on the fast path here, so we'll build our key, statically cache it,
+        // and use a borrowed reference to it for this and future operations.
         quote! {
             {
-                static METRICS_INIT: metrics::OnceIdentifier = metrics::OnceIdentifier::new();
+                static CACHED_KEY: metrics::OnceKeyData = metrics::OnceKeyData::new();
 
                 // Only do this work if there's a recorder installed.
                 if let Some(recorder) = metrics::try_recorder() {
-                    // Initialize our fast path cached identifier.
-                    let id = METRICS_INIT.get_or_init(|| {
-                        recorder.#register_ident(#key, None)
-                    });
-                    recorder.#op_ident(id, #op_values);
+                    // Initialize our fast path.
+                    let key = CACHED_KEY.get_or_init(|| { #key });
+                    recorder.#op_ident(metrics::Key::Borrowed(&key), #op_values);
                 }
             }
         }
@@ -244,14 +244,21 @@ where
             {
                 // Only do this work if there's a recorder installed.
                 if let Some(recorder) = metrics::try_recorder() {
-                    let id = recorder.#register_ident(#key, None);
-                    recorder.#op_ident(id, #op_values);
+                    recorder.#op_ident(metrics::Key::Owned(#key), #op_values);
                 }
             }
         }
-    };
+    }
+}
 
-    TokenStream::from(expanded)
+fn can_use_fast_path(labels: &Option<Labels>) -> bool {
+    match labels {
+        None => true,
+        Some(labels) => match labels {
+            Labels::Existing(_) => false,
+            Labels::Inline(pairs) => pairs.iter().all(|(_, v)| matches!(v, Expr::Lit(_))),
+        },
+    }
 }
 
 fn read_key(input: &mut ParseStream) -> Result<Key> {
@@ -265,8 +272,8 @@ fn read_key(input: &mut ParseStream) -> Result<Key> {
     }
 }
 
-fn key_to_quoted(key: Key, labels: Option<Labels>) -> proc_macro2::TokenStream {
-    let name = match key {
+fn quote_key_name(key: Key) -> proc_macro2::TokenStream {
+    match key {
         Key::NotScoped(s) => {
             quote! { #s }
         }
@@ -275,45 +282,22 @@ fn key_to_quoted(key: Key, labels: Option<Labels>) -> proc_macro2::TokenStream {
                 format!("{}.{}", std::module_path!().replace("::", "."), #s)
             }
         }
-    };
-
-    match labels {
-        None => quote! { metrics::Key::from_name(#name) },
-        Some(labels) => match labels {
-            Labels::Inline(pairs) => {
-                let labels = pairs
-                    .into_iter()
-                    .map(|(k, v)| quote! { metrics::Label::new(#k, #v) });
-                quote! {
-                    metrics::Key::from_name_and_labels(#name, vec![#(#labels),*])
-                }
-            }
-            Labels::Existing(e) => {
-                quote! {
-                    metrics::Key::from_name_and_labels(#name, #e)
-                }
-            }
-        },
     }
 }
 
-fn can_use_fast_path(labels: &Option<Labels>) -> bool {
+fn key_to_quoted(key: Key, labels: Option<Labels>) -> proc_macro2::TokenStream {
+    let name = quote_key_name(key);
+
     match labels {
-        None => true,
+        None => quote! { metrics::KeyData::from_name(#name) },
         Some(labels) => match labels {
-            Labels::Existing(_) => false,
             Labels::Inline(pairs) => {
-                let mut use_fast_path = true;
-                for (_, lvalue) in pairs {
-                    match lvalue {
-                        Expr::Lit(_) => {}
-                        _ => {
-                            use_fast_path = false;
-                        }
-                    }
-                }
-                use_fast_path
+                let labels = pairs
+                    .into_iter()
+                    .map(|(key, val)| quote! { metrics::Label::new(#key, #val) });
+                quote! { metrics::KeyData::from_name_and_labels(#name, vec![#(#labels),*]) }
             }
+            Labels::Existing(e) => quote! { metrics::KeyData::from_name_and_labels(#name, #e) },
         },
     }
 }
@@ -345,6 +329,10 @@ fn parse_labels(input: &mut ParseStream) -> Result<Option<Labels>> {
                 break;
             }
             input.parse::<Token![,]>()?;
+            if input.is_empty() {
+                break;
+            }
+
             let lkey: LitStr = input.parse()?;
             input.parse::<Token![=>]>()?;
             let lvalue: Expr = input.parse()?;
@@ -355,13 +343,25 @@ fn parse_labels(input: &mut ParseStream) -> Result<Option<Labels>> {
         return Ok(Some(Labels::Inline(labels)));
     }
 
-    // Has to be an expression otherwise.
+    // Has to be an expression otherwise, or a trailing comma.
     input.parse::<Token![,]>()?;
+
+    // Unless it was an expression - clear the trailing comma.
+    if input.is_empty() {
+        return Ok(None);
+    }
+
     let lvalue: Expr = input.parse().map_err(|e| {
         Error::new(
             e.span(),
             "expected label expression, but expression not found",
         )
     })?;
+
+    // Expression can end with a trailing comma, handle it.
+    if input.peek(Token![,]) {
+        input.parse::<Token![,]>()?;
+    }
+
     Ok(Some(Labels::Existing(lvalue)))
 }
diff --git a/metrics-macros/src/tests.rs b/metrics-macros/src/tests.rs
new file mode 100644
index 00000000..ff4f7868
--- /dev/null
+++ b/metrics-macros/src/tests.rs
@@ -0,0 +1,138 @@
+use syn::parse_quote;
+
+use super::*;
+
+#[test]
+fn test_quote_key_name_scoped() {
+    let stream = quote_key_name(Key::Scoped(parse_quote! {"qwerty"}));
+    let expected =
+        "format ! ( \"{}.{}\" , std :: module_path ! ( ) . replace ( \"::\" , \".\" ) , \"qwerty\" )";
+    assert_eq!(stream.to_string(), expected);
+}
+
+#[test]
+fn test_quote_key_name_not_scoped() {
+    let stream = quote_key_name(Key::NotScoped(parse_quote! {"qwerty"}));
+    let expected = "\"qwerty\"";
+    assert_eq!(stream.to_string(), expected);
+}
+
+#[test]
+fn test_get_expanded_registration() {
+    let stream = get_expanded_registration(
+        "mytype",
+        Key::NotScoped(parse_quote! {"mykeyname"}),
+        None,
+        None,
+    );
+
+    let expected = concat!(
+        "{ if let Some ( recorder ) = metrics :: try_recorder ( ) { ",
+        "recorder . register_mytype ( ",
+        "metrics :: Key :: Owned ( metrics :: KeyData :: from_name ( \"mykeyname\" ) ) , ",
+        "None ",
+        ") ; ",
+        "} }",
+    );
+
+    assert_eq!(stream.to_string(), expected);
+}
+
+/// If there are no dynamic labels - generate an invocation with caching.
+#[test]
+fn test_get_expanded_callsite_fast_path() {
+    let stream = get_expanded_callsite(
+        "mytype",
+        "myop",
+        Key::NotScoped(parse_quote! {"mykeyname"}),
+        None,
+        quote! { 1 },
+    );
+
+    let expected = concat!(
+        "{ ",
+        "static CACHED_KEY : metrics :: OnceKeyData = metrics :: OnceKeyData :: new ( ) ; ",
+        "if let Some ( recorder ) = metrics :: try_recorder ( ) { ",
+        "let key = CACHED_KEY . get_or_init ( || { ",
+        "metrics :: KeyData :: from_name ( \"mykeyname\" ) ",
+        "} ) ; ",
+        "recorder . myop_mytype ( metrics :: Key :: Borrowed ( & key ) , 1 ) ; ",
+        "} }",
+    );
+
+    assert_eq!(stream.to_string(), expected);
+}
+
+/// If there are dynamic labels - generate a direct invocation.
+#[test]
+fn test_get_expanded_callsite_regular_path() {
+    let stream = get_expanded_callsite(
+        "mytype",
+        "myop",
+        Key::NotScoped(parse_quote! {"mykeyname"}),
+        Some(Labels::Existing(parse_quote! { mylabels })),
+        quote! { 1 },
+    );
+
+    let expected = concat!(
+        "{ ",
+        "if let Some ( recorder ) = metrics :: try_recorder ( ) { ",
+        "recorder . myop_mytype ( ",
+        "metrics :: Key :: Owned ( metrics :: KeyData :: from_name_and_labels ( \"mykeyname\" , mylabels ) ) , ",
+        "1 ",
+        ") ; ",
+        "} }",
+    );
+
+    assert_eq!(stream.to_string(), expected);
+}
+
+#[test]
+fn test_key_to_quoted_no_labels() {
+    let stream = key_to_quoted(Key::NotScoped(parse_quote! {"mykeyname"}), None);
+    let expected = "metrics :: KeyData :: from_name ( \"mykeyname\" )";
+    assert_eq!(stream.to_string(), expected);
+}
+
+#[test]
+fn test_key_to_quoted_existing_labels() {
+    let stream = key_to_quoted(
+        Key::NotScoped(parse_quote! {"mykeyname"}),
+        Some(Labels::Existing(Expr::Path(parse_quote! { mylabels }))),
+    );
+    let expected = "metrics :: KeyData :: from_name_and_labels ( \"mykeyname\" , mylabels )";
+    assert_eq!(stream.to_string(), expected);
+}
+
+/// Registration can only operate on static labels (i.e. labels baked into the
+/// Key).
+#[test]
+fn test_key_to_quoted_inline_labels() {
+    let stream = key_to_quoted(
+        Key::NotScoped(parse_quote! {"mykeyname"}),
+        Some(Labels::Inline(vec![
+            (parse_quote! {"mylabel1"}, parse_quote! { mylabel1 }),
+            (parse_quote! {"mylabel2"}, parse_quote! { "mylabel2" }),
+        ])),
+    );
+    let expected = concat!(
+        "metrics :: KeyData :: from_name_and_labels ( \"mykeyname\" , vec ! [ ",
+        "metrics :: Label :: new ( \"mylabel1\" , mylabel1 ) , ",
+        "metrics :: Label :: new ( \"mylabel2\" , \"mylabel2\" ) ",
+        "] )"
+    );
+    assert_eq!(stream.to_string(), expected);
+}
+
+#[test]
+fn test_key_to_quoted_inline_labels_empty() {
+    let stream = key_to_quoted(
+        Key::NotScoped(parse_quote! {"mykeyname"}),
+        Some(Labels::Inline(vec![])),
+    );
+    let expected = concat!(
+        "metrics :: KeyData :: from_name_and_labels ( \"mykeyname\" , vec ! [ ",
+        "] )"
+    );
+    assert_eq!(stream.to_string(), expected);
+}
diff --git a/metrics-tracing-context/Cargo.toml b/metrics-tracing-context/Cargo.toml
new file mode 100644
index 00000000..7fd39b2b
--- /dev/null
+++ b/metrics-tracing-context/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "metrics-tracing-context"
+version = "0.1.0-alpha1"
+authors = ["MOZGIII <mike-n@narod.ru>"]
+edition = "2018"
+
+license = "MIT"
+
+description = "A crate to use tracing context as metrics labels."
+homepage = "https://github.com/metrics-rs/metrics"
+repository = "https://github.com/metrics-rs/metrics"
+documentation = "https://docs.rs/metrics"
+readme = "README.md"
+
+categories = ["development-tools::debugging"]
+keywords = ["metrics", "tracing"]
+
+[dependencies]
+metrics = { version = "0.13.0-alpha.1", path = "../metrics", features = ["std"] }
+metrics-util = { version = "0.4.0-alpha.1", path = "../metrics-util" }
+tracing = "0.1"
+tracing-core = "0.1"
+tracing-subscriber = "0.2"
+
+[dev-dependencies]
+parking_lot = "0.11"
diff --git a/metrics-tracing-context/README.md b/metrics-tracing-context/README.md
new file mode 100644
index 00000000..6bbf810a
--- /dev/null
+++ b/metrics-tracing-context/README.md
@@ -0,0 +1,3 @@
+# metrics-tracing-context
+
+A crate to use tracing context as metrics labels.
diff --git a/metrics-tracing-context/src/label_filter.rs b/metrics-tracing-context/src/label_filter.rs
new file mode 100644
index 00000000..a9b43ba3
--- /dev/null
+++ b/metrics-tracing-context/src/label_filter.rs
@@ -0,0 +1,20 @@
+//! Label filtering.
+
+use metrics::Label;
+
+/// [`LabelFilter`] trait encapsulates the ability to filter labels, i.e.
+/// determining whether a particular span field should be included as a label or not.
+pub trait LabelFilter {
+    /// Returns `true` if the passed label should be included in the key.
+    fn should_include_label(&self, label: &Label) -> bool;
+}
+
+/// A [`LabelFilter`] that allows all labels.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub struct IncludeAll;
+
+impl LabelFilter for IncludeAll {
+    fn should_include_label(&self, _label: &Label) -> bool {
+        true
+    }
+}
diff --git a/metrics-tracing-context/src/lib.rs b/metrics-tracing-context/src/lib.rs
new file mode 100644
index 00000000..c1b9368a
--- /dev/null
+++ b/metrics-tracing-context/src/lib.rs
@@ -0,0 +1,165 @@
+//! Use [`tracing::span!`] fields as [`metrics`] labels.
+//!
+//! The `metrics-tracing-context` crate provides tools to enable injecting the
+//! contextual data maintained via `span!` macro from the [`tracing`] crate
+//! into the metrics.
+//!
+//! # Use
+//!
+//! First, set up `tracing` and `metrics` crates:
+//!
+//! ```rust
+//! # use metrics_util::DebuggingRecorder;
+//! # use tracing_subscriber::Registry;
+//! use metrics_util::layers::Layer;
+//! use tracing_subscriber::layer::SubscriberExt;
+//! use metrics_tracing_context::{MetricsLayer, TracingContextLayer};
+//!
+//! // Prepare tracing.
+//! # let mysubscriber = Registry::default();
+//! let subscriber = mysubscriber.with(MetricsLayer::new());
+//! tracing::subscriber::set_global_default(subscriber).unwrap();
+//!
+//! // Prepare metrics.
+//! # let myrecorder = DebuggingRecorder::new();
+//! let recorder = TracingContextLayer::all().layer(myrecorder);
+//! metrics::set_boxed_recorder(Box::new(recorder)).unwrap();
+//! ```
+//!
+//! Then emit some metrics within spans and see the labels being injected!
+//!
+//! ```rust
+//! # use metrics_util::{layers::Layer, DebuggingRecorder};
+//! # use tracing_subscriber::{layer::SubscriberExt, Registry};
+//! # use metrics_tracing_context::{MetricsLayer, TracingContextLayer};
+//! # let mysubscriber = Registry::default();
+//! # let subscriber = mysubscriber.with(MetricsLayer::new());
+//! # tracing::subscriber::set_global_default(subscriber).unwrap();
+//! # let myrecorder = DebuggingRecorder::new();
+//! # let recorder = TracingContextLayer::all().layer(myrecorder);
+//! # metrics::set_boxed_recorder(Box::new(recorder)).unwrap();
+//! use tracing::{span, Level};
+//! use metrics::counter;
+//!
+//! let user = "ferris";
+//! let span = span!(Level::TRACE, "login", user);
+//! let _guard = span.enter();
+//!
+//! counter!("login_attempts", 1, "service" => "login_service");
+//! ```
+//!
+//! The code above will emit a increment for a `login_attempts` counter with
+//! the following labels:
+//! - `service=login_service`
+//! - `user=ferris`
+
+#![deny(missing_docs)]
+
+use metrics::{Key, KeyData, Label, Recorder};
+use metrics_util::layers::Layer;
+use tracing::Span;
+
+pub mod label_filter;
+mod tracing_integration;
+
+pub use label_filter::LabelFilter;
+pub use tracing_integration::{MetricsLayer, SpanExt};
+
+/// [`TracingContextLayer`] provides an implementation of a [`metrics::Layer`]
+/// for [`TracingContext`].
+pub struct TracingContextLayer<F> {
+    label_filter: F,
+}
+
+impl<F> TracingContextLayer<F> {
+    /// Creates a new [`TracingContextLayer`].
+    pub fn new(label_filter: F) -> Self {
+        Self { label_filter }
+    }
+}
+
+impl TracingContextLayer<label_filter::IncludeAll> {
+    /// Creates a new [`TracingContextLayer`].
+    pub fn all() -> Self {
+        Self {
+            label_filter: label_filter::IncludeAll,
+        }
+    }
+}
+
+impl<R, F> Layer<R> for TracingContextLayer<F>
+where
+    F: Clone,
+{
+    type Output = TracingContext<R, F>;
+
+    fn layer(&self, inner: R) -> Self::Output {
+        TracingContext {
+            inner,
+            label_filter: self.label_filter.clone(),
+        }
+    }
+}
+
+/// [`TracingContext`] is a [`metrics::Recorder`] that injects labels from the
+/// [`tracing::Span`]s.
+pub struct TracingContext<R, F> {
+    inner: R,
+    label_filter: F,
+}
+
+impl<R, F> TracingContext<R, F>
+where
+    F: LabelFilter,
+{
+    fn enhance_labels(&self, labels: &mut Vec<Label>) {
+        let span = Span::current();
+        span.with_labels(|new_labels| {
+            labels.extend(
+                new_labels
+                    .iter()
+                    .filter(|&label| self.label_filter.should_include_label(label))
+                    .cloned(),
+            );
+        });
+    }
+
+    fn enhance_key(&self, key: Key) -> Key {
+        let (name, mut labels) = key.into_owned().into_parts();
+        self.enhance_labels(&mut labels);
+        KeyData::from_name_and_labels(name, labels).into()
+    }
+}
+
+impl<R, F> Recorder for TracingContext<R, F>
+where
+    R: Recorder,
+    F: LabelFilter,
+{
+    fn register_counter(&self, key: Key, description: Option<&'static str>) {
+        self.inner.register_counter(key, description)
+    }
+
+    fn register_gauge(&self, key: Key, description: Option<&'static str>) {
+        self.inner.register_gauge(key, description)
+    }
+
+    fn register_histogram(&self, key: Key, description: Option<&'static str>) {
+        self.inner.register_histogram(key, description)
+    }
+
+    fn increment_counter(&self, key: Key, value: u64) {
+        let key = self.enhance_key(key);
+        self.inner.increment_counter(key, value);
+    }
+
+    fn update_gauge(&self, key: Key, value: f64) {
+        let key = self.enhance_key(key);
+        self.inner.update_gauge(key, value);
+    }
+
+    fn record_histogram(&self, key: Key, value: u64) {
+        let key = self.enhance_key(key);
+        self.inner.record_histogram(key, value);
+    }
+}
diff --git a/metrics-tracing-context/src/tracing_integration.rs b/metrics-tracing-context/src/tracing_integration.rs
new file mode 100644
index 00000000..c68040f7
--- /dev/null
+++ b/metrics-tracing-context/src/tracing_integration.rs
@@ -0,0 +1,133 @@
+//! The code that integrates with the `tracing` crate.
+
+use metrics::Label;
+use std::{any::TypeId, marker::PhantomData};
+use tracing_core::span::{Attributes, Id, Record};
+use tracing_core::{field::Visit, Dispatch, Field, Subscriber};
+use tracing_subscriber::{layer::Context, registry::LookupSpan, Layer};
+
+struct Labels(Vec<Label>);
+
+impl Visit for Labels {
+    fn record_str(&mut self, field: &Field, value: &str) {
+        let label = Label::new(field.name(), value.to_owned());
+        self.0.push(label);
+    }
+
+    fn record_debug(&mut self, field: &Field, value: &dyn std::fmt::Debug) {
+        let value_string = format!("{:?}", value);
+        let label = Label::new(field.name(), value_string);
+        self.0.push(label);
+    }
+}
+
+impl Labels {
+    fn from_attributes(attrs: &Attributes<'_>) -> Self {
+        let mut labels = Self(Vec::new()); // TODO: Vec::with_capacity?
+        let record = Record::new(attrs.values());
+        record.record(&mut labels);
+        labels
+    }
+}
+
+impl AsRef<Vec<Label>> for Labels {
+    fn as_ref(&self) -> &Vec<Label> {
+        &self.0
+    }
+}
+
+pub struct WithContext {
+    with_labels: fn(&Dispatch, &Id, f: &mut dyn FnMut(&Labels)),
+}
+
+impl WithContext {
+    pub fn with_labels<'a>(&self, dispatch: &'a Dispatch, id: &Id, f: &mut dyn FnMut(&Vec<Label>)) {
+        let mut ff = |labels: &Labels| f(labels.as_ref());
+        (self.with_labels)(dispatch, id, &mut ff)
+    }
+}
+
+/// [`MetricsLayer`] is a [`tracing_subscriber::Layer`] that captures the span
+/// fields and allows them to be later on used as metrics labels.
+pub struct MetricsLayer<S> {
+    ctx: WithContext,
+    _subscriber: PhantomData<fn(S)>,
+    _priv: (),
+}
+
+impl<S> MetricsLayer<S>
+where
+    S: Subscriber + for<'span> LookupSpan<'span>,
+{
+    /// Create a new `MetricsLayer`.
+    pub fn new() -> Self {
+        let ctx = WithContext {
+            with_labels: Self::with_labels,
+        };
+
+        Self {
+            ctx,
+            _subscriber: PhantomData,
+            _priv: (),
+        }
+    }
+
+    fn with_labels(dispatch: &Dispatch, id: &Id, f: &mut dyn FnMut(&Labels)) {
+        let span = {
+            let subscriber = dispatch
+                .downcast_ref::<S>()
+                .expect("subscriber should downcast to expected type; this is a bug!");
+            subscriber
+                .span(id)
+                .expect("registry should have a span for the current ID")
+        };
+
+        let parents = span.parents();
+        for span in std::iter::once(span).chain(parents) {
+            let extensions = span.extensions();
+            if let Some(value) = extensions.get::<Labels>() {
+                f(value);
+            }
+        }
+    }
+}
+
+impl<S> Layer<S> for MetricsLayer<S>
+where
+    S: Subscriber + for<'a> LookupSpan<'a>,
+{
+    fn new_span(&self, attrs: &Attributes<'_>, id: &Id, cx: Context<'_, S>) {
+        let span = cx.span(id).expect("span must already exist!");
+        let labels = Labels::from_attributes(attrs);
+        span.extensions_mut().insert(labels);
+    }
+
+    unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
+        match id {
+            id if id == TypeId::of::<Self>() => Some(self as *const _ as *const ()),
+            id if id == TypeId::of::<WithContext>() => Some(&self.ctx as *const _ as *const ()),
+            _ => None,
+        }
+    }
+}
+
+/// An extention to the `tracing::Span`, enabling the access to labels.
+pub trait SpanExt {
+    /// Run the provided function with a read-only access to labels.
+    fn with_labels<F>(&self, f: F)
+    where
+        F: FnMut(&Vec<Label>);
+}
+
+impl SpanExt for tracing::Span {
+    fn with_labels<F>(&self, mut f: F)
+    where
+        F: FnMut(&Vec<Label>),
+    {
+        self.with_subscriber(|(id, subscriber)| {
+            if let Some(ctx) = subscriber.downcast_ref::<WithContext>() {
+                ctx.with_labels(subscriber, id, &mut f)
+            }
+        });
+    }
+}
diff --git a/metrics-tracing-context/tests/integration.rs b/metrics-tracing-context/tests/integration.rs
new file mode 100644
index 00000000..308aeff1
--- /dev/null
+++ b/metrics-tracing-context/tests/integration.rs
@@ -0,0 +1,347 @@
+use std::collections::HashSet;
+
+use metrics::{counter, KeyData, Label};
+use metrics_tracing_context::{LabelFilter, MetricsLayer, TracingContextLayer};
+use metrics_util::{layers::Layer, DebugValue, DebuggingRecorder, MetricKind, Snapshotter};
+use parking_lot::{const_mutex, Mutex, MutexGuard};
+use tracing::dispatcher::{set_default, DefaultGuard, Dispatch};
+use tracing::{span, Level};
+use tracing_subscriber::{layer::SubscriberExt, Registry};
+
+static TEST_MUTEX: Mutex<()> = const_mutex(());
+
+struct TestGuard {
+    _test_mutex_guard: MutexGuard<'static, ()>,
+    _tracing_guard: DefaultGuard,
+}
+
+fn setup<F>(layer: TracingContextLayer<F>) -> (TestGuard, Snapshotter)
+where
+    F: LabelFilter + Clone + 'static,
+{
+    let test_mutex_guard = TEST_MUTEX.lock();
+    let subscriber = Registry::default().with(MetricsLayer::new());
+    let tracing_guard = set_default(&Dispatch::new(subscriber));
+
+    let recorder = DebuggingRecorder::new();
+    let snapshotter = recorder.snapshotter();
+    let recorder = layer.layer(recorder);
+
+    metrics::clear_recorder();
+    metrics::set_boxed_recorder(Box::new(recorder)).expect("failed to install recorder");
+
+    let test_guard = TestGuard {
+        _test_mutex_guard: test_mutex_guard,
+        _tracing_guard: tracing_guard,
+    };
+    (test_guard, snapshotter)
+}
+
+#[test]
+fn test_basic_functionality() {
+    let (_guard, snapshotter) = setup(TracingContextLayer::all());
+
+    let user = "ferris";
+    let email = "ferris@rust-lang.org";
+    let span = span!(Level::TRACE, "login", user, user.email = email);
+    let _guard = span.enter();
+
+    counter!("login_attempts", 1, "service" => "login_service");
+
+    let snapshot = snapshotter.snapshot();
+
+    assert_eq!(
+        snapshot,
+        vec![(
+            MetricKind::Counter,
+            KeyData::from_name_and_labels(
+                "login_attempts",
+                vec![
+                    Label::new("service", "login_service"),
+                    Label::new("user", "ferris"),
+                    Label::new("user.email", "ferris@rust-lang.org"),
+                ],
+            )
+            .into(),
+            DebugValue::Counter(1),
+        )]
+    )
+}
+
+#[test]
+fn test_macro_forms() {
+    let (_guard, snapshotter) = setup(TracingContextLayer::all());
+
+    let user = "ferris";
+    let email = "ferris@rust-lang.org";
+    let span = span!(Level::TRACE, "login", user, user.email = email);
+    let _guard = span.enter();
+
+    // No labels.
+    counter!("login_attempts_no_labels", 1);
+    // Static labels only.
+    counter!("login_attempts_static_labels", 1, "service" => "login_service");
+    // Dynamic labels only.
+    let node_name = "localhost".to_string();
+    counter!("login_attempts_dynamic_labels", 1, "node_name" => node_name.clone());
+    // Static and dynamic.
+    counter!("login_attempts_static_and_dynamic_labels", 1,
+        "service" => "login_service", "node_name" => node_name.clone());
+
+    let snapshot = snapshotter.snapshot();
+    let snapshot: HashSet<_> = snapshot.into_iter().collect();
+
+    assert_eq!(
+        snapshot,
+        vec![
+            (
+                MetricKind::Counter,
+                KeyData::from_name_and_labels(
+                    "login_attempts_no_labels",
+                    vec![
+                        Label::new("user", "ferris"),
+                        Label::new("user.email", "ferris@rust-lang.org"),
+                    ],
+                )
+                .into(),
+                DebugValue::Counter(1),
+            ),
+            (
+                MetricKind::Counter,
+                KeyData::from_name_and_labels(
+                    "login_attempts_static_labels",
+                    vec![
+                        Label::new("service", "login_service"),
+                        Label::new("user", "ferris"),
+                        Label::new("user.email", "ferris@rust-lang.org"),
+                    ],
+                )
+                .into(),
+                DebugValue::Counter(1),
+            ),
+            (
+                MetricKind::Counter,
+                KeyData::from_name_and_labels(
+                    "login_attempts_dynamic_labels",
+                    vec![
+                        Label::new("node_name", "localhost"),
+                        Label::new("user", "ferris"),
+                        Label::new("user.email", "ferris@rust-lang.org"),
+                    ],
+                )
+                .into(),
+                DebugValue::Counter(1),
+            ),
+            (
+                MetricKind::Counter,
+                KeyData::from_name_and_labels(
+                    "login_attempts_static_and_dynamic_labels",
+                    vec![
+                        Label::new("service", "login_service"),
+                        Label::new("node_name", "localhost"),
+                        Label::new("user", "ferris"),
+                        Label::new("user.email", "ferris@rust-lang.org"),
+                    ],
+                )
+                .into(),
+                DebugValue::Counter(1),
+            ),
+        ]
+        .into_iter()
+        .collect()
+    )
+}
+
+#[test]
+fn test_no_labels() {
+    let (_guard, snapshotter) = setup(TracingContextLayer::all());
+
+    let span = span!(Level::TRACE, "login");
+    let _guard = span.enter();
+
+    counter!("login_attempts", 1);
+
+    let snapshot = snapshotter.snapshot();
+
+    assert_eq!(
+        snapshot,
+        vec![(
+            MetricKind::Counter,
+            KeyData::from_name("login_attempts").into(),
+            DebugValue::Counter(1),
+        )]
+    )
+}
+
+#[test]
+fn test_multiple_paths_to_the_same_callsite() {
+    let (_guard, snapshotter) = setup(TracingContextLayer::all());
+
+    let shared_fn = || {
+        counter!("my_counter", 1);
+    };
+
+    let path1 = || {
+        let path1_specific_dynamic = "foo_dynamic";
+        let span = span!(
+            Level::TRACE,
+            "path1",
+            shared_field = "path1",
+            path1_specific = "foo",
+            path1_specific_dynamic,
+        );
+        let _guard = span.enter();
+        shared_fn();
+    };
+
+    let path2 = || {
+        let path2_specific_dynamic = "bar_dynamic";
+        let span = span!(
+            Level::TRACE,
+            "path2",
+            shared_field = "path2",
+            path2_specific = "bar",
+            path2_specific_dynamic,
+        );
+        let _guard = span.enter();
+        shared_fn();
+    };
+
+    path1();
+    path2();
+
+    let snapshot = snapshotter.snapshot();
+    let snapshot: HashSet<_> = snapshot.into_iter().collect();
+
+    assert_eq!(
+        snapshot,
+        vec![
+            (
+                MetricKind::Counter,
+                KeyData::from_name_and_labels(
+                    "my_counter",
+                    vec![
+                        Label::new("shared_field", "path1"),
+                        Label::new("path1_specific", "foo"),
+                        Label::new("path1_specific_dynamic", "foo_dynamic"),
+                    ],
+                )
+                .into(),
+                DebugValue::Counter(1),
+            ),
+            (
+                MetricKind::Counter,
+                KeyData::from_name_and_labels(
+                    "my_counter",
+                    vec![
+                        Label::new("shared_field", "path2"),
+                        Label::new("path2_specific", "bar"),
+                        Label::new("path2_specific_dynamic", "bar_dynamic"),
+                    ],
+                )
+                .into(),
+                DebugValue::Counter(1),
+            )
+        ]
+        .into_iter()
+        .collect()
+    )
+}
+
+#[test]
+fn test_nested_spans() {
+    let (_guard, snapshotter) = setup(TracingContextLayer::all());
+
+    let inner = || {
+        let inner_specific_dynamic = "foo_dynamic";
+        let span = span!(
+            Level::TRACE,
+            "inner",
+            shared_field = "inner",
+            inner_specific = "foo",
+            inner_specific_dynamic,
+        );
+        let _guard = span.enter();
+
+        counter!("my_counter", 1);
+    };
+
+    let outer = || {
+        let outer_specific_dynamic = "bar_dynamic";
+        let span = span!(
+            Level::TRACE,
+            "outer",
+            shared_field = "outer",
+            outer_specific = "bar",
+            outer_specific_dynamic,
+        );
+        let _guard = span.enter();
+        inner();
+    };
+
+    outer();
+
+    let snapshot = snapshotter.snapshot();
+    let snapshot: HashSet<_> = snapshot.into_iter().collect();
+
+    assert_eq!(
+        snapshot,
+        vec![(
+            MetricKind::Counter,
+            KeyData::from_name_and_labels(
+                "my_counter",
+                vec![
+                    Label::new("shared_field", "inner"),
+                    Label::new("inner_specific", "foo"),
+                    Label::new("inner_specific_dynamic", "foo_dynamic"),
+                    Label::new("shared_field", "outer"),
+                    Label::new("outer_specific", "bar"),
+                    Label::new("outer_specific_dynamic", "bar_dynamic"),
+                ],
+            )
+            .into(),
+            DebugValue::Counter(1),
+        ),]
+        .into_iter()
+        .collect()
+    )
+}
+
+#[derive(Clone)]
+struct OnlyUser;
+
+impl LabelFilter for OnlyUser {
+    fn should_include_label(&self, label: &Label) -> bool {
+        label.key() == "user"
+    }
+}
+
+#[test]
+fn test_label_filtering() {
+    let (_guard, snapshotter) = setup(TracingContextLayer::new(OnlyUser));
+
+    let user = "ferris";
+    let email = "ferris@rust-lang.org";
+    let span = span!(Level::TRACE, "login", user, user.email = email);
+    let _guard = span.enter();
+
+    counter!("login_attempts", 1, "service" => "login_service");
+
+    let snapshot = snapshotter.snapshot();
+
+    assert_eq!(
+        snapshot,
+        vec![(
+            MetricKind::Counter,
+            KeyData::from_name_and_labels(
+                "login_attempts",
+                vec![
+                    Label::new("service", "login_service"),
+                    Label::new("user", "ferris"),
+                ],
+            )
+            .into(),
+            DebugValue::Counter(1),
+        )]
+    )
+}
diff --git a/metrics-util/Cargo.toml b/metrics-util/Cargo.toml
index 89604e7e..a0e39df7 100644
--- a/metrics-util/Cargo.toml
+++ b/metrics-util/Cargo.toml
@@ -15,6 +15,9 @@ readme = "README.md"
 categories = ["development-tools::debugging"]
 keywords = ["metrics", "quantile", "percentile"]
 
+[lib]
+bench = false
+
 [[bench]]
 name = "bucket"
 harness = false
@@ -33,9 +36,9 @@ crossbeam-epoch = "^0.8"
 crossbeam-utils = "^0.7"
 serde = "^1.0"
 arc-swap = "^0.4"
-im = "^15"
 parking_lot = "^0.10"
 aho-corasick = { version = "^0.7", optional = true }
+dashmap = "3"
 
 [dev-dependencies]
 criterion = "^0.3"
diff --git a/metrics-util/benches/registry.rs b/metrics-util/benches/registry.rs
index c23965b8..e9673428 100644
--- a/metrics-util/benches/registry.rs
+++ b/metrics-util/benches/registry.rs
@@ -2,56 +2,54 @@
 extern crate criterion;
 
 use criterion::{BatchSize, Benchmark, Criterion};
-use metrics::{Key, Label};
+use metrics::{Key, KeyData, Label, OnceKeyData};
 use metrics_util::Registry;
 
 fn registry_benchmark(c: &mut Criterion) {
     c.bench(
         "registry",
-        Benchmark::new("cached get/create (basic)", |b| {
+        Benchmark::new("cached op (basic)", |b| {
             let registry: Registry<Key, ()> = Registry::new();
+            static KEY_DATA: OnceKeyData = OnceKeyData::new();
 
             b.iter(|| {
-                let key = "simple_key".into();
-                let _ = registry.get_or_create_identifier(key, |_| ());
+                let key = Key::Borrowed(KEY_DATA.get_or_init(|| KeyData::from_name("simple_key")));
+                registry.op(key, |_| (), || ())
             })
         })
-        .with_function("cached get/create (labels)", |b| {
+        .with_function("cached op (labels)", |b| {
             let registry: Registry<Key, ()> = Registry::new();
+            static KEY_DATA: OnceKeyData = OnceKeyData::new();
 
             b.iter(|| {
-                let labels = vec![Label::new("type", "http")];
-                let key = ("simple_key", labels).into();
-                let _ = registry.get_or_create_identifier(key, |_| ());
+                let key = Key::Borrowed(KEY_DATA.get_or_init(|| {
+                    let labels = vec![Label::new("type", "http")];
+                    KeyData::from_name_and_labels("simple_key", labels)
+                }));
+                registry.op(key, |_| (), || ())
             })
         })
-        .with_function("uncached get/create (basic)", |b| {
+        .with_function("uncached op (basic)", |b| {
             b.iter_batched_ref(
                 || Registry::<Key, ()>::new(),
                 |registry| {
-                    let key = "simple_key".into();
-                    let _ = registry.get_or_create_identifier(key, |_| ());
+                    let key = Key::Owned("simple_key".into());
+                    registry.op(key, |_| (), || ())
                 },
                 BatchSize::SmallInput,
             )
         })
-        .with_function("uncached get/create (labels)", |b| {
+        .with_function("uncached op (labels)", |b| {
             b.iter_batched_ref(
                 || Registry::<Key, ()>::new(),
                 |registry| {
                     let labels = vec![Label::new("type", "http")];
-                    let key = ("simple_key", labels).into();
-                    let _ = registry.get_or_create_identifier(key, |_| ());
+                    let key = Key::Owned(("simple_key", labels).into());
+                    registry.op(key, |_| (), || ())
                 },
                 BatchSize::SmallInput,
             )
         })
-        .with_function("with handle", |b| {
-            let registry = Registry::<Key, ()>::new();
-            let id = registry.get_or_create_identifier("foo".into(), |_| ());
-
-            b.iter(|| registry.with_handle(id, |_| {}))
-        })
         .with_function("registry overhead", |b| {
             b.iter_batched(
                 || (),
@@ -59,17 +57,51 @@ fn registry_benchmark(c: &mut Criterion) {
                 BatchSize::NumIterations(1),
             )
         })
-        .with_function("key overhead (basic)", |b| {
+        .with_function("key data overhead (basic)", |b| {
+            b.iter(|| {
+                let key = "simple_key";
+                KeyData::from_name(key)
+            })
+        })
+        .with_function("key data overhead (labels)", |b| {
+            b.iter(|| {
+                let key = "simple_key";
+                let labels = vec![Label::new("type", "http")];
+                KeyData::from_name_and_labels(key, labels)
+            })
+        })
+        .with_function("owned key overhead (basic)", |b| {
             b.iter(|| {
                 let key = "simple_key";
-                let _: Key = key.into();
+                Key::Owned(KeyData::from_name(key))
             })
         })
-        .with_function("key overhead (labels)", |b| {
+        .with_function("owned key overhead (labels)", |b| {
             b.iter(|| {
                 let key = "simple_key";
                 let labels = vec![Label::new("type", "http")];
-                let _: Key = (key, labels).into();
+                Key::Owned(KeyData::from_name_and_labels(key, labels))
+            })
+        })
+        .with_function("cached key overhead (basic)", |b| {
+            static KEY_DATA: OnceKeyData = OnceKeyData::new();
+            b.iter(|| {
+                let key_data = KEY_DATA.get_or_init(|| {
+                    let key = "simple_key";
+                    KeyData::from_name(key)
+                });
+                Key::Borrowed(key_data)
+            })
+        })
+        .with_function("cached key overhead (labels)", |b| {
+            static KEY_DATA: OnceKeyData = OnceKeyData::new();
+            b.iter(|| {
+                let key_data = KEY_DATA.get_or_init(|| {
+                    let key = "simple_key";
+                    let labels = vec![Label::new("type", "http")];
+                    KeyData::from_name_and_labels(key, labels)
+                });
+                Key::Borrowed(key_data)
             })
         }),
     );
diff --git a/metrics-util/src/debugging.rs b/metrics-util/src/debugging.rs
index 5524fe42..5db01197 100644
--- a/metrics-util/src/debugging.rs
+++ b/metrics-util/src/debugging.rs
@@ -1,11 +1,11 @@
-use std::sync::Arc;
+use std::{hash::Hash, hash::Hasher, sync::Arc};
 
 use crate::{handle::Handle, registry::Registry};
 
-use metrics::{Identifier, Key, Recorder};
+use metrics::{Key, Recorder};
 
 /// Metric kinds.
-#[derive(Eq, PartialEq, Hash, Clone, Copy)]
+#[derive(Debug, Eq, PartialEq, Hash, Clone, Copy, Ord, PartialOrd)]
 pub enum MetricKind {
     /// Counter.
     Counter,
@@ -27,6 +27,7 @@ impl DifferentiatedKey {
 }
 
 /// A point-in-time value for a metric exposing raw values.
+#[derive(Debug, PartialEq)]
 pub enum DebugValue {
     /// Counter.
     Counter(u64),
@@ -36,6 +37,26 @@ pub enum DebugValue {
     Histogram(Vec<u64>),
 }
 
+// We don't care that much about total equality nuances here.
+impl Eq for DebugValue {}
+
+impl Hash for DebugValue {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        match self {
+            Self::Counter(val) => val.hash(state),
+            Self::Gauge(val) => {
+                // Whatever works, we don't really care in here...
+                if val.is_normal() {
+                    val.to_ne_bytes().hash(state)
+                } else {
+                    0f64.to_ne_bytes().hash(state)
+                }
+            }
+            Self::Histogram(val) => val.hash(state),
+        }
+    }
+}
+
 /// Captures point-in-time snapshots of `DebuggingRecorder`.
 pub struct Snapshotter {
     registry: Arc<Registry<DifferentiatedKey, Handle>>,
@@ -89,36 +110,45 @@ impl DebuggingRecorder {
 }
 
 impl Recorder for DebuggingRecorder {
-    fn register_counter(&self, key: Key, _description: Option<&'static str>) -> Identifier {
+    fn register_counter(&self, key: Key, _description: Option<&'static str>) {
         let rkey = DifferentiatedKey(MetricKind::Counter, key);
-        self.registry
-            .get_or_create_identifier(rkey, |_| Handle::counter())
+        self.registry.op(rkey, |_| {}, || Handle::counter())
     }
 
-    fn register_gauge(&self, key: Key, _description: Option<&'static str>) -> Identifier {
+    fn register_gauge(&self, key: Key, _description: Option<&'static str>) {
         let rkey = DifferentiatedKey(MetricKind::Gauge, key);
-        self.registry
-            .get_or_create_identifier(rkey, |_| Handle::gauge())
+        self.registry.op(rkey, |_| {}, || Handle::gauge())
     }
 
-    fn register_histogram(&self, key: Key, _description: Option<&'static str>) -> Identifier {
+    fn register_histogram(&self, key: Key, _description: Option<&'static str>) {
         let rkey = DifferentiatedKey(MetricKind::Histogram, key);
-        self.registry
-            .get_or_create_identifier(rkey, |_| Handle::histogram())
+        self.registry.op(rkey, |_| {}, || Handle::histogram())
     }
 
-    fn increment_counter(&self, id: Identifier, value: u64) {
-        self.registry
-            .with_handle(id, |handle| handle.increment_counter(value));
+    fn increment_counter(&self, key: Key, value: u64) {
+        let rkey = DifferentiatedKey(MetricKind::Counter, key);
+        self.registry.op(
+            rkey,
+            |handle| handle.increment_counter(value),
+            || Handle::counter(),
+        )
     }
 
-    fn update_gauge(&self, id: Identifier, value: f64) {
-        self.registry
-            .with_handle(id, |handle| handle.update_gauge(value));
+    fn update_gauge(&self, key: Key, value: f64) {
+        let rkey = DifferentiatedKey(MetricKind::Gauge, key);
+        self.registry.op(
+            rkey,
+            |handle| handle.update_gauge(value),
+            || Handle::gauge(),
+        )
     }
 
-    fn record_histogram(&self, id: Identifier, value: u64) {
-        self.registry
-            .with_handle(id, |handle| handle.record_histogram(value));
+    fn record_histogram(&self, key: Key, value: u64) {
+        let rkey = DifferentiatedKey(MetricKind::Histogram, key);
+        self.registry.op(
+            rkey,
+            |handle| handle.record_histogram(value),
+            || Handle::histogram(),
+        )
     }
 }
diff --git a/metrics-util/src/layers/filter.rs b/metrics-util/src/layers/filter.rs
index 0d96c515..4d2b7e9b 100644
--- a/metrics-util/src/layers/filter.rs
+++ b/metrics-util/src/layers/filter.rs
@@ -1,6 +1,6 @@
 use crate::layers::Layer;
 use aho_corasick::{AhoCorasick, AhoCorasickBuilder};
-use metrics::{Identifier, Key, Recorder};
+use metrics::{Key, Recorder};
 
 /// Filters and discards metrics matching certain name patterns.
 ///
@@ -18,43 +18,46 @@ impl<R> Filter<R> {
 }
 
 impl<R: Recorder> Recorder for Filter<R> {
-    fn register_counter(&self, key: Key, description: Option<&'static str>) -> Identifier {
+    fn register_counter(&self, key: Key, description: Option<&'static str>) {
         if self.should_filter(&key) {
-            return Identifier::Invalid;
+            return;
         }
         self.inner.register_counter(key, description)
     }
 
-    fn register_gauge(&self, key: Key, description: Option<&'static str>) -> Identifier {
+    fn register_gauge(&self, key: Key, description: Option<&'static str>) {
         if self.should_filter(&key) {
-            return Identifier::Invalid;
+            return;
         }
         self.inner.register_gauge(key, description)
     }
 
-    fn register_histogram(&self, key: Key, description: Option<&'static str>) -> Identifier {
+    fn register_histogram(&self, key: Key, description: Option<&'static str>) {
         if self.should_filter(&key) {
-            return Identifier::Invalid;
+            return;
         }
         self.inner.register_histogram(key, description)
     }
 
-    fn increment_counter(&self, id: Identifier, value: u64) {
-        if let Identifier::Valid(_) = id {
-            self.inner.increment_counter(id, value);
+    fn increment_counter(&self, key: Key, value: u64) {
+        if self.should_filter(&key) {
+            return;
         }
+        self.inner.increment_counter(key, value);
     }
 
-    fn update_gauge(&self, id: Identifier, value: f64) {
-        if let Identifier::Valid(_) = id {
-            self.inner.update_gauge(id, value);
+    fn update_gauge(&self, key: Key, value: f64) {
+        if self.should_filter(&key) {
+            return;
         }
+        self.inner.update_gauge(key, value);
     }
 
-    fn record_histogram(&self, id: Identifier, value: u64) {
-        if let Identifier::Valid(_) = id {
-            self.inner.record_histogram(id, value);
+    fn record_histogram(&self, key: Key, value: u64) {
+        if self.should_filter(&key) {
+            return;
         }
+        self.inner.record_histogram(key, value);
     }
 }
 
@@ -132,7 +135,7 @@ mod tests {
     use super::FilterLayer;
     use crate::debugging::DebuggingRecorder;
     use crate::layers::Layer;
-    use metrics::Recorder;
+    use metrics::{Key, Recorder};
 
     #[test]
     fn test_basic_functionality() {
@@ -145,11 +148,11 @@ mod tests {
         let before = snapshotter.snapshot();
         assert_eq!(before.len(), 0);
 
-        layered.register_counter("tokio.loops".into(), None);
-        layered.register_gauge("hyper.sent_bytes".into(), None);
-        layered.register_histogram("hyper.recv_bytes".into(), None);
-        layered.register_counter("bb8.conns".into(), None);
-        layered.register_gauge("hyper.tokio.sent_bytes".into(), None);
+        layered.register_counter(Key::Owned("tokio.loops".into()), None);
+        layered.register_gauge(Key::Owned("hyper.sent_bytes".into()), None);
+        layered.register_histogram(Key::Owned("hyper.recv_bytes".into()), None);
+        layered.register_counter(Key::Owned("bb8.conns".into()), None);
+        layered.register_gauge(Key::Owned("hyper.tokio.sent_bytes".into()), None);
 
         let after = snapshotter.snapshot();
         assert_eq!(after.len(), 2);
@@ -171,11 +174,11 @@ mod tests {
         let before = snapshotter.snapshot();
         assert_eq!(before.len(), 0);
 
-        layered.register_counter("tokiO.loops".into(), None);
-        layered.register_gauge("hyper.sent_bytes".into(), None);
-        layered.register_histogram("hyper.recv_bytes".into(), None);
-        layered.register_counter("bb8.conns".into(), None);
-        layered.register_counter("Bb8.conns_closed".into(), None);
+        layered.register_counter(Key::Owned("tokiO.loops".into()), None);
+        layered.register_gauge(Key::Owned("hyper.sent_bytes".into()), None);
+        layered.register_histogram(Key::Owned("hyper.recv_bytes".into()), None);
+        layered.register_counter(Key::Owned("bb8.conns".into()), None);
+        layered.register_counter(Key::Owned("Bb8.conns_closed".into()), None);
 
         let after = snapshotter.snapshot();
         assert_eq!(after.len(), 2);
diff --git a/metrics-util/src/layers/mod.rs b/metrics-util/src/layers/mod.rs
index ac2d4a18..17e8a7ea 100644
--- a/metrics-util/src/layers/mod.rs
+++ b/metrics-util/src/layers/mod.rs
@@ -8,7 +8,7 @@
 //! Here's an example of a layer that filters out all metrics that start with a specific string:
 //!
 //! ```rust
-//! # use metrics::{Key, Identifier, Recorder};
+//! # use metrics::{Key, Recorder};
 //! # use metrics_util::DebuggingRecorder;
 //! # use metrics_util::layers::{Layer, Stack, PrefixLayer};
 //! // A simple layer that denies any metrics that have "stairway" or "heaven" in their name.
@@ -22,43 +22,46 @@
 //! }
 //!
 //! impl<R: Recorder> Recorder for StairwayDeny<R> {
-//!    fn register_counter(&self, key: Key, description: Option<&'static str>) -> Identifier {
+//!    fn register_counter(&self, key: Key, description: Option<&'static str>) {
 //!        if self.is_invalid_key(&key) {
-//!            return Identifier::Invalid;
+//!            return;
 //!        }
 //!        self.0.register_counter(key, description)
 //!    }
 //!
-//!    fn register_gauge(&self, key: Key, description: Option<&'static str>) -> Identifier {
+//!    fn register_gauge(&self, key: Key, description: Option<&'static str>) {
 //!        if self.is_invalid_key(&key) {
-//!            return Identifier::Invalid;
+//!            return;
 //!        }
 //!        self.0.register_gauge(key, description)
 //!    }
 //!
-//!    fn register_histogram(&self, key: Key, description: Option<&'static str>) -> Identifier {
+//!    fn register_histogram(&self, key: Key, description: Option<&'static str>) {
 //!        if self.is_invalid_key(&key) {
-//!            return Identifier::Invalid;
+//!            return;
 //!        }
 //!        self.0.register_histogram(key, description)
 //!    }
 //!
-//!    fn increment_counter(&self, id: Identifier, value: u64) {
-//!        if let Identifier::Valid(_) = id {
-//!            self.0.increment_counter(id, value);
+//!    fn increment_counter(&self, key: Key, value: u64) {
+//!        if self.is_invalid_key(&key) {
+//!            return;
 //!        }
+//!        self.0.increment_counter(key, value);
 //!    }
 //!
-//!    fn update_gauge(&self, id: Identifier, value: f64) {
-//!        if let Identifier::Valid(_) = id {
-//!            self.0.update_gauge(id, value);
+//!    fn update_gauge(&self, key: Key, value: f64) {
+//!        if self.is_invalid_key(&key) {
+//!            return;
 //!        }
+//!        self.0.update_gauge(key, value);
 //!    }
 //!
-//!    fn record_histogram(&self, id: Identifier, value: u64) {
-//!        if let Identifier::Valid(_) = id {
-//!            self.0.record_histogram(id, value);
+//!    fn record_histogram(&self, key: Key, value: u64) {
+//!        if self.is_invalid_key(&key) {
+//!            return;
 //!        }
+//!        self.0.record_histogram(key, value);
 //!    }
 //! }
 //!
@@ -99,7 +102,7 @@
 //!     .expect("failed to install stack");
 //! # }
 //! ```
-use metrics::{Identifier, Key, Recorder};
+use metrics::{Key, Recorder};
 
 #[cfg(feature = "std")]
 use metrics::SetRecorderError;
@@ -149,27 +152,27 @@ impl<R: Recorder + 'static> Stack<R> {
 }
 
 impl<R: Recorder> Recorder for Stack<R> {
-    fn register_counter(&self, key: Key, description: Option<&'static str>) -> Identifier {
+    fn register_counter(&self, key: Key, description: Option<&'static str>) {
         self.inner.register_counter(key, description)
     }
 
-    fn register_gauge(&self, key: Key, description: Option<&'static str>) -> Identifier {
+    fn register_gauge(&self, key: Key, description: Option<&'static str>) {
         self.inner.register_gauge(key, description)
     }
 
-    fn register_histogram(&self, key: Key, description: Option<&'static str>) -> Identifier {
+    fn register_histogram(&self, key: Key, description: Option<&'static str>) {
         self.inner.register_histogram(key, description)
     }
 
-    fn increment_counter(&self, id: Identifier, value: u64) {
-        self.inner.increment_counter(id, value);
+    fn increment_counter(&self, key: Key, value: u64) {
+        self.inner.increment_counter(key, value);
     }
 
-    fn update_gauge(&self, id: Identifier, value: f64) {
-        self.inner.update_gauge(id, value);
+    fn update_gauge(&self, key: Key, value: f64) {
+        self.inner.update_gauge(key, value);
     }
 
-    fn record_histogram(&self, id: Identifier, value: u64) {
-        self.inner.record_histogram(id, value);
+    fn record_histogram(&self, key: Key, value: u64) {
+        self.inner.record_histogram(key, value);
     }
 }
diff --git a/metrics-util/src/layers/prefix.rs b/metrics-util/src/layers/prefix.rs
index af4a9ebb..16b4d1b1 100644
--- a/metrics-util/src/layers/prefix.rs
+++ b/metrics-util/src/layers/prefix.rs
@@ -1,5 +1,5 @@
 use crate::layers::Layer;
-use metrics::{Identifier, Key, Recorder};
+use metrics::{Key, Recorder};
 
 /// Applies a prefix to every metric key.
 ///
@@ -11,36 +11,41 @@ pub struct Prefix<R> {
 
 impl<R> Prefix<R> {
     fn prefix_key(&self, key: Key) -> Key {
-        key.map_name(|old| format!("{}.{}", self.prefix, old))
+        key.into_owned()
+            .map_name(|old| format!("{}.{}", self.prefix, old))
+            .into()
     }
 }
 
 impl<R: Recorder> Recorder for Prefix<R> {
-    fn register_counter(&self, key: Key, description: Option<&'static str>) -> Identifier {
+    fn register_counter(&self, key: Key, description: Option<&'static str>) {
         let new_key = self.prefix_key(key);
         self.inner.register_counter(new_key, description)
     }
 
-    fn register_gauge(&self, key: Key, description: Option<&'static str>) -> Identifier {
+    fn register_gauge(&self, key: Key, description: Option<&'static str>) {
         let new_key = self.prefix_key(key);
         self.inner.register_gauge(new_key, description)
     }
 
-    fn register_histogram(&self, key: Key, description: Option<&'static str>) -> Identifier {
+    fn register_histogram(&self, key: Key, description: Option<&'static str>) {
         let new_key = self.prefix_key(key);
         self.inner.register_histogram(new_key, description)
     }
 
-    fn increment_counter(&self, id: Identifier, value: u64) {
-        self.inner.increment_counter(id, value);
+    fn increment_counter(&self, key: Key, value: u64) {
+        let new_key = self.prefix_key(key);
+        self.inner.increment_counter(new_key, value);
     }
 
-    fn update_gauge(&self, id: Identifier, value: f64) {
-        self.inner.update_gauge(id, value);
+    fn update_gauge(&self, key: Key, value: f64) {
+        let new_key = self.prefix_key(key);
+        self.inner.update_gauge(new_key, value);
     }
 
-    fn record_histogram(&self, id: Identifier, value: u64) {
-        self.inner.record_histogram(id, value);
+    fn record_histogram(&self, key: Key, value: u64) {
+        let new_key = self.prefix_key(key);
+        self.inner.record_histogram(new_key, value);
     }
 }
 
@@ -72,7 +77,7 @@ mod tests {
     use super::PrefixLayer;
     use crate::debugging::DebuggingRecorder;
     use crate::layers::Layer;
-    use metrics::Recorder;
+    use metrics::{KeyData, Recorder};
 
     #[test]
     fn test_basic_functionality() {
@@ -84,9 +89,9 @@ mod tests {
         let before = snapshotter.snapshot();
         assert_eq!(before.len(), 0);
 
-        layered.register_counter("counter_metric".into(), None);
-        layered.register_gauge("gauge_metric".into(), None);
-        layered.register_histogram("histogram_metric".into(), None);
+        layered.register_counter(KeyData::from_name("counter_metric").into(), None);
+        layered.register_gauge(KeyData::from_name("gauge_metric").into(), None);
+        layered.register_histogram(KeyData::from_name("histogram_metric").into(), None);
 
         let after = snapshotter.snapshot();
         assert_eq!(after.len(), 3);
diff --git a/metrics-util/src/registry.rs b/metrics-util/src/registry.rs
index e10dec7d..75767877 100644
--- a/metrics-util/src/registry.rs
+++ b/metrics-util/src/registry.rs
@@ -1,12 +1,6 @@
+use dashmap::DashMap;
 use std::collections::HashMap;
 use std::hash::Hash;
-use std::sync::Arc;
-
-use arc_swap::ArcSwap;
-use crossbeam_utils::sync::ShardedLock;
-use im::HashMap as ImmutableHashMap;
-use metrics::Identifier;
-use parking_lot::Mutex;
 
 /// A high-performance metric registry.
 ///
@@ -25,9 +19,7 @@ use parking_lot::Mutex;
 ///
 /// `Registry` is optimized for reads.
 pub struct Registry<K, H> {
-    mappings: ArcSwap<ImmutableHashMap<K, Identifier>>,
-    handles: ShardedLock<Vec<H>>,
-    lock: Mutex<()>,
+    map: DashMap<K, H>,
 }
 
 impl<K, H> Registry<K, H>
@@ -36,96 +28,39 @@ where
 {
     /// Creates a new `Registry`.
     pub fn new() -> Self {
-        Registry {
-            mappings: ArcSwap::from(Arc::new(ImmutableHashMap::new())),
-            handles: ShardedLock::new(Vec::new()),
-            lock: Mutex::new(()),
+        Self {
+            map: DashMap::new(),
         }
     }
 
-    /// Get or create a new identifier for a given key.
+    /// Perform an operation on a given key.
     ///
-    /// If the key is not already mapped, a new identifier will be generated, and the given handle
-    /// stored along side of it.  If the key is already mapped, its identifier will be returned.
-    pub fn get_or_create_identifier<F>(&self, key: K, f: F) -> Identifier
-    where
-        F: FnOnce(&K) -> H,
-    {
-        // Check our mapping table first.
-        if let Some(id) = self.mappings.load().get(&key) {
-            return id.clone();
-        }
-
-        // Take control of the registry.
-        let guard = self.lock.lock();
-
-        // Check our mapping table again, in case someone just inserted what we need.
-        let mappings = self.mappings.load();
-        if let Some(id) = mappings.get(&key) {
-            return id.clone();
-        }
-
-        // Our identifier will be the index we insert the handle into.
-        let mut wg = self
-            .handles
-            .write()
-            .expect("handles write lock was poisoned!");
-        let id = wg.len().into();
-        let handle = f(&key);
-        wg.push(handle);
-        drop(wg);
-
-        // Update our mapping table and drop the lock.
-        let new_mappings = mappings.update(key, id);
-        drop(mappings);
-        self.mappings.store(Arc::new(new_mappings));
-        drop(guard);
-
-        id
-    }
-
-    /// Gets the handle for a given identifier.
-    pub fn with_handle<F, V>(&self, identifier: Identifier, f: F) -> Option<V>
+    /// The `op` function will be called for the handle under the given `key`.
+    ///
+    /// If the `key` is not already mapped, the `init` function will be
+    /// called, and the resulting handle will be stored in the registry.
+    pub fn op<I, O, V>(&self, key: K, op: O, init: I) -> V
     where
-        F: FnOnce(&H) -> V,
+        I: FnOnce() -> H,
+        O: FnOnce(&H) -> V,
     {
-        match identifier {
-            Identifier::Valid(idx) => {
-                let rg = self
-                    .handles
-                    .read()
-                    .expect("handles read lock was poisoned!");
-                rg.get(idx).map(f)
-            }
-            Identifier::Invalid => None,
-        }
+        let valref = self.map.entry(key).or_insert_with(init);
+        op(valref.value())
     }
 }
 
 impl<K, H> Registry<K, H>
 where
-    K: Eq + Hash + Clone,
-    H: Clone,
+    K: Eq + Hash + Clone + 'static,
+    H: Clone + 'static,
 {
     /// Gets a map of all present handles, mapped by key.
     ///
     /// Handles must implement `Clone`.  This map is a point-in-time snapshot of the registry.
     pub fn get_handles(&self) -> HashMap<K, H> {
-        let guard = self.mappings.load();
-        let mappings = ImmutableHashMap::clone(&guard);
-        let rg = self
-            .handles
-            .read()
-            .expect("handles read lock was poisoned!");
-        mappings
-            .into_iter()
-            .filter_map(|(key, id)| match id {
-                Identifier::Valid(idx) => {
-                    let handle = rg.get(idx).expect("handle not present!").clone();
-                    Some((key, handle))
-                }
-                Identifier::Invalid => None,
-            })
-            .collect::<HashMap<_, _>>()
+        self.map
+            .iter()
+            .map(|item| (item.key().clone(), item.value().clone()))
+            .collect()
     }
 }
diff --git a/metrics/Cargo.toml b/metrics/Cargo.toml
index f20c0e76..abd4f6c1 100644
--- a/metrics/Cargo.toml
+++ b/metrics/Cargo.toml
@@ -20,6 +20,9 @@ build = "build.rs"
 [package.metadata.docs.rs]
 features = ["std"]
 
+[lib]
+bench = false
+
 [[bench]]
 name = "macros"
 harness = false
@@ -27,11 +30,13 @@ harness = false
 [dependencies]
 metrics-macros = { version = "0.1.0-alpha.1", path = "../metrics-macros" }
 proc-macro-hack = "^0.5"
+once_cell = "1"
 
 [dev-dependencies]
 log = "^0.4"
 criterion = "^0.3"
 rand = "^0.7"
+trybuild = "1"
 
 [features]
 default = ["std"]
diff --git a/metrics/benches/macros.rs b/metrics/benches/macros.rs
index 78b7c3b8..5472eaf6 100644
--- a/metrics/benches/macros.rs
+++ b/metrics/benches/macros.rs
@@ -3,24 +3,18 @@ extern crate criterion;
 
 use criterion::{Benchmark, Criterion};
 
-use metrics::{counter, Identifier, Key, Recorder};
+use metrics::{counter, Key, Recorder};
 use rand::{thread_rng, Rng};
 
 #[derive(Default)]
 struct TestRecorder;
 impl Recorder for TestRecorder {
-    fn register_counter(&self, _key: Key, _description: Option<&'static str>) -> Identifier {
-        thread_rng().gen::<usize>().into()
-    }
-    fn register_gauge(&self, _key: Key, _description: Option<&'static str>) -> Identifier {
-        thread_rng().gen::<usize>().into()
-    }
-    fn register_histogram(&self, _key: Key, _description: Option<&'static str>) -> Identifier {
-        thread_rng().gen::<usize>().into()
-    }
-    fn increment_counter(&self, _id: Identifier, _value: u64) {}
-    fn update_gauge(&self, _id: Identifier, _value: f64) {}
-    fn record_histogram(&self, _id: Identifier, _value: u64) {}
+    fn register_counter(&self, _key: Key, _description: Option<&'static str>) {}
+    fn register_gauge(&self, _key: Key, _description: Option<&'static str>) {}
+    fn register_histogram(&self, _key: Key, _description: Option<&'static str>) {}
+    fn increment_counter(&self, _key: Key, _value: u64) {}
+    fn update_gauge(&self, _key: Key, _value: f64) {}
+    fn record_histogram(&self, _key: Key, _value: u64) {}
 }
 
 fn reset_recorder() {
@@ -31,31 +25,31 @@ fn reset_recorder() {
 fn macro_benchmark(c: &mut Criterion) {
     c.bench(
         "macros",
-        Benchmark::new("uninitialized/no labels", |b| {
+        Benchmark::new("uninitialized/no_labels", |b| {
             b.iter(|| {
                 counter!("counter_bench", 42);
             })
         })
-        .with_function("uninitialized/with static labels", |b| {
+        .with_function("uninitialized/with_static_labels", |b| {
             b.iter(|| {
                 counter!("counter_bench", 42, "request" => "http", "svc" => "admin");
             })
         })
-        .with_function("initialized/no labels", |b| {
+        .with_function("initialized/no_labels", |b| {
             reset_recorder();
             b.iter(|| {
                 counter!("counter_bench", 42);
             });
             metrics::clear_recorder();
         })
-        .with_function("initialized/with static labels", |b| {
+        .with_function("initialized/with_static_labels", |b| {
             reset_recorder();
             b.iter(|| {
                 counter!("counter_bench", 42, "request" => "http", "svc" => "admin");
             });
             metrics::clear_recorder();
         })
-        .with_function("initialized/with dynamic labels", |b| {
+        .with_function("initialized/with_dynamic_labels", |b| {
             let label_val = thread_rng().gen::<u64>().to_string();
 
             reset_recorder();
diff --git a/metrics/examples/basic.rs b/metrics/examples/basic.rs
index 8028794d..0f40bddc 100644
--- a/metrics/examples/basic.rs
+++ b/metrics/examples/basic.rs
@@ -1,48 +1,43 @@
-use std::sync::atomic::{AtomicUsize, Ordering};
-
-use metrics::{counter, gauge, histogram, increment, Identifier, Key, Recorder};
+use metrics::{counter, gauge, histogram, increment, Key, Recorder};
 
 #[allow(dead_code)]
-static RECORDER: PrintRecorder = PrintRecorder::new();
+static RECORDER: PrintRecorder = PrintRecorder;
 
 #[derive(Default)]
-struct PrintRecorder(AtomicUsize);
-
-impl PrintRecorder {
-    pub const fn new() -> PrintRecorder {
-        PrintRecorder(AtomicUsize::new(0))
-    }
-}
+struct PrintRecorder;
 
 impl Recorder for PrintRecorder {
-    fn register_counter(&self, key: Key, _description: Option<&'static str>) -> Identifier {
-        let id = self.0.fetch_add(1, Ordering::SeqCst);
-        println!("(counter) mapping key {} to id {}", key, id);
-        id.into()
+    fn register_counter(&self, key: Key, description: Option<&'static str>) {
+        println!(
+            "(counter) registered key {} with description {:?}",
+            key, description
+        );
     }
 
-    fn register_gauge(&self, key: Key, _description: Option<&'static str>) -> Identifier {
-        let id = self.0.fetch_add(1, Ordering::SeqCst);
-        println!("(gauge) mapping key {} to id {}", key, id);
-        id.into()
+    fn register_gauge(&self, key: Key, description: Option<&'static str>) {
+        println!(
+            "(gauge) registered key {} with description {:?}",
+            key, description
+        );
     }
 
-    fn register_histogram(&self, key: Key, _description: Option<&'static str>) -> Identifier {
-        let id = self.0.fetch_add(1, Ordering::SeqCst);
-        println!("(histogram) mapping key {} to id {}", key, id);
-        id.into()
+    fn register_histogram(&self, key: Key, description: Option<&'static str>) {
+        println!(
+            "(histogram) registered key {} with description {:?}",
+            key, description
+        );
     }
 
-    fn increment_counter(&self, id: Identifier, value: u64) {
-        println!("(counter) got value {} for id {:?}", value, id);
+    fn increment_counter(&self, key: Key, value: u64) {
+        println!("(counter) got value {} for key {}", value, key);
     }
 
-    fn update_gauge(&self, id: Identifier, value: f64) {
-        println!("(gauge) got value {} for id {:?}", value, id);
+    fn update_gauge(&self, key: Key, value: f64) {
+        println!("(gauge) got value {} for key {}", value, key);
     }
 
-    fn record_histogram(&self, id: Identifier, value: u64) {
-        println!("(histogram) got value {} for id {:?}", value, id);
+    fn record_histogram(&self, key: Key, value: u64) {
+        println!("(histogram) got value {} for key {}", value, key);
     }
 }
 
diff --git a/metrics/src/common.rs b/metrics/src/common.rs
index 8f33f226..270f51fb 100644
--- a/metrics/src/common.rs
+++ b/metrics/src/common.rs
@@ -1,6 +1,4 @@
 use std::borrow::Cow;
-use std::cell::UnsafeCell;
-use std::sync::Once;
 
 /// An allocation-optimized string.
 ///
@@ -9,75 +7,6 @@ use std::sync::Once;
 /// take ownership of owned strings and borrows of completely static strings.
 pub type ScopedString = Cow<'static, str>;
 
-/// Opaque identifier for a metric.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum Identifier {
-    /// An uninitialized or invalid identifier.
-    ///
-    /// Used either as a default value where static construction is required, or in special cases
-    /// where an invalid identifier must be returned to signal downstream layers to not process a
-    /// particular call i.e. filtering metrics by returning an invalid identifier during registration.
-    Invalid,
-
-    /// A valid identifier.
-    Valid(usize),
-}
-
-impl Default for Identifier {
-    fn default() -> Self {
-        Identifier::Invalid
-    }
-}
-
-impl From<usize> for Identifier {
-    fn from(v: usize) -> Self {
-        Identifier::Valid(v)
-    }
-}
-
-/// Atomically-guarded identifier initialization.
-///
-/// Stores an identifier in an atomically-backed fashion, allowing for multiple callers to
-/// race on creating the identifier, as well as waiting until it has been created, before
-/// being able to take a reference to it.
-pub struct OnceIdentifier {
-    init: Once,
-    inner: UnsafeCell<Identifier>,
-}
-
-impl OnceIdentifier {
-    /// Creates a new `OnceIdentifier` in the uninitialized state.
-    pub const fn new() -> OnceIdentifier {
-        OnceIdentifier {
-            init: Once::new(),
-            inner: UnsafeCell::new(Identifier::Invalid),
-        }
-    }
-
-    /// Gets or initializes the identifier.
-    ///
-    /// If the identifier has not yet been initialized, `f` is run to acquire it, and
-    /// stores the identifier for other callers to utilize.
-    ///
-    /// All callers rondezvous on an internal atomic guard, so it impossible to see
-    /// invalid state.
-    pub fn get_or_init<F>(&self, f: F) -> Identifier
-    where
-        F: Fn() -> Identifier,
-    {
-        self.init.call_once(|| {
-            let id = f();
-            unsafe {
-                (*self.inner.get()) = id;
-            }
-        });
-
-        unsafe { *self.inner.get() }
-    }
-}
-
-unsafe impl Sync for OnceIdentifier {}
-
 /// An object which can be converted into a `u64` representation.
 ///
 /// This trait provides a mechanism for existing types, which have a natural representation
diff --git a/metrics/src/key.rs b/metrics/src/key.rs
index 4d8aa71a..b55ae713 100644
--- a/metrics/src/key.rs
+++ b/metrics/src/key.rs
@@ -1,37 +1,34 @@
 use crate::{IntoLabels, Label, ScopedString};
 use std::{fmt, slice::Iter};
 
-/// A metric key.
+/// A metric key data.
 ///
-/// A key always includes a name, but can optional include multiple labels used to further describe
-/// the metric.
+/// A key data always includes a name, but can optionally include multiple
+/// labels used to further describe the metric.
 #[derive(PartialEq, Eq, Hash, Clone, Debug)]
-pub struct Key {
+pub struct KeyData {
     name: ScopedString,
-    labels: Option<Vec<Label>>,
+    labels: Vec<Label>,
 }
 
-impl Key {
-    /// Creates a `Key` from a name.
+impl KeyData {
+    /// Creates a `KeyData` from a name.
     pub fn from_name<N>(name: N) -> Self
     where
         N: Into<ScopedString>,
     {
-        Key {
-            name: name.into(),
-            labels: None,
-        }
+        Self::from_name_and_labels(name, Vec::new())
     }
 
-    /// Creates a `Key` from a name and vector of `Label`s.
+    /// Creates a `KeyData` from a name and vector of `Label`s.
     pub fn from_name_and_labels<N, L>(name: N, labels: L) -> Self
     where
         N: Into<ScopedString>,
         L: IntoLabels,
     {
-        Key {
+        Self {
             name: name.into(),
-            labels: Some(labels.into_labels()),
+            labels: labels.into_labels(),
         }
     }
 
@@ -41,8 +38,8 @@ impl Key {
     }
 
     /// Labels of this key, if they exist.
-    pub fn labels(&self) -> Option<Iter<Label>> {
-        self.labels.as_ref().map(|xs| xs.iter())
+    pub fn labels(&self) -> Iter<Label> {
+        self.labels.iter()
     }
 
     /// Map the name of this key to a new name, based on `f`.
@@ -58,82 +55,186 @@ impl Key {
     }
 
     /// Consumes this `Key`, returning the name and any labels.
-    pub fn into_parts(self) -> (ScopedString, Option<Vec<Label>>) {
+    pub fn into_parts(self) -> (ScopedString, Vec<Label>) {
         (self.name, self.labels)
     }
+
+    /// Returns a clone of this key with some additional labels.
+    pub fn with_extra_labels(&self, extra_labels: Vec<Label>) -> Self {
+        if extra_labels.is_empty() {
+            return self.clone();
+        }
+
+        let name = self.name.clone();
+        let mut labels = self.labels.clone();
+        labels.extend(extra_labels);
+
+        Self { name, labels }
+    }
 }
 
-impl fmt::Display for Key {
+impl fmt::Display for KeyData {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match &self.labels {
-            None => write!(f, "Key({})", self.name),
-            Some(labels) => {
-                write!(f, "Key({}", self.name)?;
-
-                if !labels.is_empty() {
-                    let mut first = true;
-                    write!(f, ", [")?;
-                    for label in labels {
-                        if first {
-                            write!(f, "{} = {}", label.0, label.1)?;
-                            first = false;
-                        } else {
-                            write!(f, ", {} = {}", label.0, label.1)?;
-                        }
-                    }
-                    write!(f, "]")?;
+        if self.labels.is_empty() {
+            write!(f, "KeyData({})", self.name)
+        } else {
+            write!(f, "KeyData({}, [", self.name)?;
+            let mut first = true;
+            for label in &self.labels {
+                if first {
+                    write!(f, "{} = {}", label.0, label.1)?;
+                    first = false;
+                } else {
+                    write!(f, ", {} = {}", label.0, label.1)?;
                 }
-                write!(f, ")")
             }
+            write!(f, "])")
         }
     }
 }
 
-impl From<String> for Key {
-    fn from(name: String) -> Key {
-        Key::from_name(name)
+impl From<String> for KeyData {
+    fn from(name: String) -> Self {
+        Self::from_name(name)
     }
 }
 
-impl From<&'static str> for Key {
-    fn from(name: &'static str) -> Key {
-        Key::from_name(name)
+impl From<&'static str> for KeyData {
+    fn from(name: &'static str) -> Self {
+        Self::from_name(name)
     }
 }
 
-impl<N, L> From<(N, L)> for Key
+impl<N, L> From<(N, L)> for KeyData
 where
     N: Into<ScopedString>,
     L: IntoLabels,
 {
-    fn from(parts: (N, L)) -> Key {
-        Key::from_name_and_labels(parts.0, parts.1)
+    fn from(parts: (N, L)) -> Self {
+        Self::from_name_and_labels(parts.0, parts.1)
+    }
+}
+
+/// Represents the identifier of a metric.
+///
+/// [`Key`] holds either an owned or static reference variant of [`KeyData`].
+///
+/// This allows for flexibility in the ways that [`KeyData`] can be passed around
+/// and reused, enabling performance improvements in specific situations.
+#[derive(Debug, Hash, Clone)]
+pub enum Key {
+    /// A statically borrowed [`KeyData`].
+    ///
+    /// If you are capable of keeping a static [`KeyData`] around, this variant can
+    /// be used to reduce allocations and improve performance.
+    ///
+    /// The reference is read-only, so you can't modify the underlying data.
+    Borrowed(&'static KeyData),
+    /// An owned [`KeyData`].
+    ///
+    /// Useful when you need to modify a borrowed [`KeyData`] in-flight, or when
+    /// there's no way to keep around a static [`KeyData`] reference.
+    Owned(KeyData),
+}
+
+impl PartialEq for Key {
+    /// We deliberately hide the differences between the containment types.
+    fn eq(&self, other: &Self) -> bool {
+        self.as_ref() == other.as_ref()
+    }
+}
+
+impl Eq for Key {}
+
+impl Key {
+    /// Converts any kind of [`Key`] into an owned [`KeyData`].
+    ///
+    /// Owned variant returned as is, borrowed variant is cloned.
+    pub fn into_owned(self) -> KeyData {
+        match self {
+            Self::Borrowed(val) => val.clone(),
+            Self::Owned(val) => val,
+        }
+    }
+}
+
+impl std::ops::Deref for Key {
+    type Target = KeyData;
+
+    #[must_use]
+    fn deref(&self) -> &Self::Target {
+        match self {
+            Self::Borrowed(val) => val,
+            Self::Owned(val) => val,
+        }
+    }
+}
+
+impl AsRef<KeyData> for Key {
+    #[must_use]
+    fn as_ref(&self) -> &KeyData {
+        match self {
+            Self::Borrowed(val) => val,
+            Self::Owned(val) => val,
+        }
+    }
+}
+
+impl fmt::Display for Key {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::Borrowed(val) => val.fmt(f),
+            Self::Owned(val) => val.fmt(f),
+        }
+    }
+}
+
+// Here we don't provide generic `From` impls
+// (i.e. `impl <T: Into<KeyData>> From<T> for Key`) because the decision whether
+// to construct the owned or borrowed ref is important for performance, and
+// we want users of this type to explicitly make this decision rather than rely
+// on the the magic of `.into()`.
+
+impl From<KeyData> for Key {
+    fn from(key_data: KeyData) -> Self {
+        Self::Owned(key_data)
     }
 }
 
+impl From<&'static KeyData> for Key {
+    fn from(key_data: &'static KeyData) -> Self {
+        Self::Borrowed(key_data)
+    }
+}
+
+/// A type to simplify management of the static `KeyData`.
+///
+/// Allows for an efficient caching of the `KeyData` at the callsites.
+pub type OnceKeyData = once_cell::sync::OnceCell<KeyData>;
+
 #[cfg(test)]
 mod tests {
-    use super::Key;
+    use super::{Key, KeyData, OnceKeyData};
     use crate::Label;
 
     #[test]
-    fn test_key_proper_display() {
-        let key1 = Key::from_name("foobar");
+    fn test_key_data_proper_display() {
+        let key1 = KeyData::from_name("foobar");
         let result1 = key1.to_string();
-        assert_eq!(result1, "Key(foobar)");
+        assert_eq!(result1, "KeyData(foobar)");
 
-        let key2 = Key::from_name_and_labels("foobar", vec![Label::new("system", "http")]);
+        let key2 = KeyData::from_name_and_labels("foobar", vec![Label::new("system", "http")]);
         let result2 = key2.to_string();
-        assert_eq!(result2, "Key(foobar, [system = http])");
+        assert_eq!(result2, "KeyData(foobar, [system = http])");
 
-        let key3 = Key::from_name_and_labels(
+        let key3 = KeyData::from_name_and_labels(
             "foobar",
             vec![Label::new("system", "http"), Label::new("user", "joe")],
         );
         let result3 = key3.to_string();
-        assert_eq!(result3, "Key(foobar, [system = http, user = joe])");
+        assert_eq!(result3, "KeyData(foobar, [system = http, user = joe])");
 
-        let key4 = Key::from_name_and_labels(
+        let key4 = KeyData::from_name_and_labels(
             "foobar",
             vec![
                 Label::new("black", "black"),
@@ -144,7 +245,36 @@ mod tests {
         let result4 = key4.to_string();
         assert_eq!(
             result4,
-            "Key(foobar, [black = black, lives = lives, matter = matter])"
+            "KeyData(foobar, [black = black, lives = lives, matter = matter])"
         );
     }
+
+    #[test]
+    fn key_equality() {
+        let owned_a = KeyData::from_name("a");
+        let owned_b = KeyData::from_name("b");
+
+        static STATIC_A: OnceKeyData = OnceKeyData::new();
+        static STATIC_B: OnceKeyData = OnceKeyData::new();
+
+        let borrowed_a = STATIC_A.get_or_init(|| owned_a.clone());
+        let borrowed_b = STATIC_B.get_or_init(|| owned_b.clone());
+
+        assert_eq!(Key::Owned(owned_a.clone()), Key::Owned(owned_a.clone()));
+        assert_eq!(Key::Owned(owned_b.clone()), Key::Owned(owned_b.clone()));
+
+        assert_eq!(Key::Borrowed(borrowed_a), Key::Borrowed(borrowed_a));
+        assert_eq!(Key::Borrowed(borrowed_b), Key::Borrowed(borrowed_b));
+
+        assert_eq!(Key::Owned(owned_a.clone()), Key::Borrowed(borrowed_a));
+        assert_eq!(Key::Owned(owned_b.clone()), Key::Borrowed(borrowed_b));
+
+        assert_eq!(Key::Borrowed(borrowed_a), Key::Owned(owned_a.clone()));
+        assert_eq!(Key::Borrowed(borrowed_b), Key::Owned(owned_b.clone()));
+
+        assert_ne!(Key::Owned(owned_a.clone()), Key::Owned(owned_b.clone()),);
+        assert_ne!(Key::Borrowed(borrowed_a), Key::Borrowed(borrowed_b));
+        assert_ne!(Key::Owned(owned_a.clone()), Key::Borrowed(borrowed_b));
+        assert_ne!(Key::Owned(owned_b.clone()), Key::Borrowed(borrowed_a));
+    }
 }
diff --git a/metrics/src/lib.rs b/metrics/src/lib.rs
index 5e58f5cb..0ac045c6 100644
--- a/metrics/src/lib.rs
+++ b/metrics/src/lib.rs
@@ -60,56 +60,27 @@
 //! metrics in text form via the `log` crate.
 //!
 //! ```rust
-//! # use std::sync::{Mutex, atomic::{AtomicUsize, Ordering}};
-//! # use std::collections::HashMap;
 //! use log::info;
-//! use metrics::{Identifier, Key, Recorder};
+//! use metrics::{Key, Recorder};
 //!
-//! struct LogRecorder {
-//!     id: AtomicUsize,
-//!     keys: Mutex<HashMap<Identifier, Key>>,
-//! }
-//!
-//! impl LogRecorder {
-//!     fn register(&self, key: Key) -> Identifier {
-//!         let uid = self.id.fetch_add(1, Ordering::AcqRel);
-//!         let id = uid.into();
-//!         let mut keys = self.keys.lock().expect("failed to lock keys");
-//!         keys.insert(id, key);
-//!         id
-//!     }
-//!
-//!     fn get_key(&self, id: Identifier) -> Key {
-//!         let keys = self.keys.lock().expect("failed to lock keys");
-//!         keys.get(&id).expect("invalid identifier").clone()
-//!     }
-//! }
+//! struct LogRecorder;
 //!
 //! impl Recorder for LogRecorder {
-//!     fn register_counter(&self, key: Key, _description: Option<&'static str>) -> Identifier {
-//!         self.register(key)
-//!     }
+//!     fn register_counter(&self, key: Key, _description: Option<&'static str>) {}
 //!
-//!     fn register_gauge(&self, key: Key, _description: Option<&'static str>) -> Identifier {
-//!         self.register(key)
-//!     }
+//!     fn register_gauge(&self, key: Key, _description: Option<&'static str>) {}
 //!
-//!     fn register_histogram(&self, key: Key, _description: Option<&'static str>) -> Identifier {
-//!         self.register(key)
-//!     }
+//!     fn register_histogram(&self, key: Key, _description: Option<&'static str>) {}
 //!
-//!     fn increment_counter(&self, id: Identifier, value: u64) {
-//!         let key = self.get_key(id);
+//!     fn increment_counter(&self, key: Key, value: u64) {
 //!         info!("counter '{}' -> {}", key, value);
 //!     }
 //!
-//!     fn update_gauge(&self, id: Identifier, value: f64) {
-//!         let key = self.get_key(id);
+//!     fn update_gauge(&self, key: Key, value: f64) {
 //!         info!("gauge '{}' -> {}", key, value);
 //!     }
 //!
-//!     fn record_histogram(&self, id: Identifier, value: u64) {
-//!         let key = self.get_key(id);
+//!     fn record_histogram(&self, key: Key, value: u64) {
 //!         info!("histogram '{}' -> {}", key, value);
 //!     }
 //! }
@@ -120,15 +91,15 @@
 //! function that wraps the creation and installation of the recorder:
 //!
 //! ```rust
-//! # use metrics::{Recorder, Key, Identifier};
+//! # use metrics::{Recorder, Key};
 //! # struct LogRecorder;
 //! # impl Recorder for LogRecorder {
-//! #     fn register_counter(&self, _key: Key, _description: Option<&'static str>) -> Identifier { Identifier::default() }
-//! #     fn register_gauge(&self, _key: Key, _description: Option<&'static str>) -> Identifier { Identifier::default() }
-//! #     fn register_histogram(&self, _key: Key, _description: Option<&'static str>) -> Identifier { Identifier::default() }
-//! #     fn increment_counter(&self, _id: Identifier, _value: u64) {}
-//! #     fn update_gauge(&self, _id: Identifier, _value: f64) {}
-//! #     fn record_histogram(&self, _id: Identifier, _value: u64) {}
+//! #     fn register_counter(&self, _key: Key, _description: Option<&'static str>) {}
+//! #     fn register_gauge(&self, _key: Key, _description: Option<&'static str>) {}
+//! #     fn register_histogram(&self, _key: Key, _description: Option<&'static str>) {}
+//! #     fn increment_counter(&self, _key: Key, _value: u64) {}
+//! #     fn update_gauge(&self, _key: Key, _value: f64) {}
+//! #     fn record_histogram(&self, _key: Key, _value: u64) {}
 //! # }
 //! use metrics::SetRecorderError;
 //!
@@ -148,15 +119,15 @@
 //! that it takes a `Box<Recorder>` rather than a `&'static Recorder`:
 //!
 //! ```rust
-//! # use metrics::{Recorder, Key, Identifier};
+//! # use metrics::{Recorder, Key};
 //! # struct LogRecorder;
 //! # impl Recorder for LogRecorder {
-//! #     fn register_counter(&self, _key: Key, _description: Option<&'static str>) -> Identifier { Identifier::default() }
-//! #     fn register_gauge(&self, _key: Key, _description: Option<&'static str>) -> Identifier { Identifier::default() }
-//! #     fn register_histogram(&self, _key: Key, _description: Option<&'static str>) -> Identifier { Identifier::default() }
-//! #     fn increment_counter(&self, _id: Identifier, _value: u64) {}
-//! #     fn update_gauge(&self, _id: Identifier, _value: f64) {}
-//! #     fn record_histogram(&self, _id: Identifier, _value: u64) {}
+//! #     fn register_counter(&self, _key: Key, _description: Option<&'static str>) {}
+//! #     fn register_gauge(&self, _key: Key, _description: Option<&'static str>) {}
+//! #     fn register_histogram(&self, _key: Key, _description: Option<&'static str>) {}
+//! #     fn increment_counter(&self, _key: Key, _value: u64) {}
+//! #     fn update_gauge(&self, _key: Key, _value: f64) {}
+//! #     fn record_histogram(&self, _key: Key, _value: u64) {}
 //! # }
 //! use metrics::SetRecorderError;
 //!
diff --git a/metrics/src/recorder.rs b/metrics/src/recorder.rs
index 4d7d91c8..287aa41a 100644
--- a/metrics/src/recorder.rs
+++ b/metrics/src/recorder.rs
@@ -1,4 +1,4 @@
-use crate::{Identifier, Key};
+use crate::Key;
 use std::fmt;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
@@ -19,50 +19,44 @@ pub trait Recorder {
     /// Callers may provide a description of the counter being registered. Whether or not a metric
     /// can be reregistered to provide a description, if one was already passed or not, as well as
     /// how descriptions are used by the underlying recorder, is an implementation detail.
-    fn register_counter(&self, key: Key, description: Option<&'static str>) -> Identifier;
+    fn register_counter(&self, key: Key, description: Option<&'static str>);
 
     /// Registers a gauge.
     ///
     /// Callers may provide a description of the counter being registered. Whether or not a metric
     /// can be reregistered to provide a description, if one was already passed or not, as well as
     /// how descriptions are used by the underlying recorder, is an implementation detail.
-    fn register_gauge(&self, key: Key, description: Option<&'static str>) -> Identifier;
+    fn register_gauge(&self, key: Key, description: Option<&'static str>);
 
     /// Registers a histogram.
     ///
     /// Callers may provide a description of the counter being registered. Whether or not a metric
     /// can be reregistered to provide a description, if one was already passed or not, as well as
     /// how descriptions are used by the underlying recorder, is an implementation detail.
-    fn register_histogram(&self, key: Key, description: Option<&'static str>) -> Identifier;
+    fn register_histogram(&self, key: Key, description: Option<&'static str>);
 
     /// Increments a counter.
-    fn increment_counter(&self, id: Identifier, value: u64);
+    fn increment_counter(&self, key: Key, value: u64);
 
     /// Updates a gauge.
-    fn update_gauge(&self, id: Identifier, value: f64);
+    fn update_gauge(&self, key: Key, value: f64);
 
     /// Records a histogram.
     ///
     /// The value can be value that implements [`IntoU64`].  By default, `metrics` provides an
     /// implementation for both `u64` itself as well as [`Duration`](std::time::Duration).
-    fn record_histogram(&self, id: Identifier, value: u64);
+    fn record_histogram(&self, key: Key, value: u64);
 }
 
 struct NoopRecorder;
 
 impl Recorder for NoopRecorder {
-    fn register_counter(&self, _key: Key, _description: Option<&'static str>) -> Identifier {
-        Identifier::default()
-    }
-    fn register_gauge(&self, _key: Key, _description: Option<&'static str>) -> Identifier {
-        Identifier::default()
-    }
-    fn register_histogram(&self, _key: Key, _description: Option<&'static str>) -> Identifier {
-        Identifier::default()
-    }
-    fn increment_counter(&self, _id: Identifier, _value: u64) {}
-    fn update_gauge(&self, _id: Identifier, _value: f64) {}
-    fn record_histogram(&self, _id: Identifier, _value: u64) {}
+    fn register_counter(&self, _key: Key, _description: Option<&'static str>) {}
+    fn register_gauge(&self, _key: Key, _description: Option<&'static str>) {}
+    fn register_histogram(&self, _key: Key, _description: Option<&'static str>) {}
+    fn increment_counter(&self, _key: Key, _value: u64) {}
+    fn update_gauge(&self, _key: Key, _value: f64) {}
+    fn record_histogram(&self, _key: Key, _value: u64) {}
 }
 
 /// Sets the global recorder to a `&'static Recorder`.
diff --git a/metrics/tests/macros_parsing.rs b/metrics/tests/macros_parsing.rs
new file mode 100644
index 00000000..66aa1777
--- /dev/null
+++ b/metrics/tests/macros_parsing.rs
@@ -0,0 +1,5 @@
+#[test]
+pub fn parsing() {
+    let t = trybuild::TestCases::new();
+    t.pass("tests/macros_parsing/*.rs");
+}
diff --git a/metrics/tests/macros_parsing/trailing_comma.rs b/metrics/tests/macros_parsing/trailing_comma.rs
new file mode 100644
index 00000000..46c695c6
--- /dev/null
+++ b/metrics/tests/macros_parsing/trailing_comma.rs
@@ -0,0 +1,21 @@
+use metrics::counter;
+
+fn no_trailing_comma() {
+    counter!("qwe", 1);
+    counter!(
+        "qwe", 1,
+        "foo" => "bar"
+    );
+    counter!("qwe", 1, vec![]);
+}
+
+fn with_trailing_comma() {
+    counter!("qwe", 1,);
+    counter!(
+        "qwe", 1,
+        "foo" => "bar",
+    );
+    counter!("qwe", 1, vec![],);
+}
+
+fn main() {}