How to avoid metric name collisions across crates? Namespacing?

[bonsairobo]

AFAICT it's very possible for two different crates to define a metric with the same name, which would likely create some confusion when trying to make sense of the data.

Should crates just prefix metric names with "crate_name::" or something?

[tobz]

You're right: it's entirely possible.

Right now, the best you can do is to indeed prefix metric names that would otherwise collide.

We do have a new (but currently unused) feature that captures "metadata" about where a metric is defined, which includes the target (crate name) and module path (e.g. crate_name::module::submodule). Using that metadata to automatically prefix metric names would solve this automatically, but it would also be a breaking change and would need to be phased in, so it wouldn't be available to help you out for a while.

[bonsairobo]

OK! I'm fine using a prefix until we have something better.

[bonsairobo]

BTW, I managed to write some wrapper macros that automatically prefix the crate name. IMO putting the entire module path into the metric name is a bad idea, since module paths are usually implementation details. Just prefixing the crate name seems like the most stable option.

macro_rules! counter {
    ($name:expr $(, $label_key:expr $(=> $label_value:expr)?)* $(,)?) => {
        metrics::counter!(
            const_str::concat!(crate::_current_crate_name(), "::", $name)
            $(, $label_key $(=> $label_value)?)*
        )
    };
}

// Macro implementation detail, not intended for public use.
#[doc(hidden)]
pub const fn _current_crate_name() -> &'static str {
    const PATH_SLICE: &[u8] = module_path!().as_bytes();
    const NAME_LEN: usize = {
        let mut i = 0;
        loop {
            if i == PATH_SLICE.len() || PATH_SLICE[i] == b':' {
                break i;
            }
            i += 1;
        }
    };
    // Range indexing is not const (yet), so we must manually construct a new array.
    const NAME_ARR: [u8; NAME_LEN] = {
        let mut arr = [0; NAME_LEN];
        let mut i = 0;
        while i < NAME_LEN {
            arr[i] = PATH_SLICE[i];
            i += 1;
        }
        arr
    };

    // SAFETY: The original string was valid UTF-8 and we sliced it at the start
    // of an ASCII byte which is a valid unicode boundary. Hence the new string is
    // still valid UTF-8.
    unsafe { std::str::from_utf8_unchecked(&NAME_ARR) }
}

[tobz]

Ah yeah, that's a neat/clean way to slap it in there for the time being. 👍🏻