Struct MetricResourceIdentifier

pub struct MetricResourceIdentifier<'a> {
    pub ty: MetricType,
    pub namespace: MetricNamespace,
    pub name: Cow<'a, str>,
    pub unit: MetricUnit,
}

A unique identifier for metrics including typing and namespacing.

MRIs have the format <type>:<namespace>/<name>[@<unit>]. The unit is optional and defaults to MetricUnit::None.

Statsd Format

In the statsd submission payload, MRIs are sent in a more relaxed format: [<namespace>/]<name>[@<unit>]. The differences to the internal MRI format are:

• Types are not part of metric naming. Instead, the type is declared in a separate field following the value.
• The namespace is optional. If missing, "custom" is assumed.

Background

MRIs follow three core principles:

1. Robustness: Metrics must be addressed via a stable identifier. During ingestion in Relay and Snuba, metrics are preaggregated and bucketed based on this identifier, so it cannot change over time without breaking bucketing.
2. Uniqueness: The identifier for metrics must be unique across variations of units and metric types, within and across use cases, as well as between projects and organizations.
3. Abstraction: The user-facing product changes its terminology over time, and splits concepts into smaller parts. The internal metric identifiers must abstract from that, and offer sufficient granularity to allow for such changes.

Example

use relay_base_schema::metrics::MetricResourceIdentifier;

let string = "c:custom/test@second";
let mri = MetricResourceIdentifier::parse(string).expect("should parse");
assert_eq!(mri.to_string(), string);

Fields

ty: MetricType

The type of a metric, determining its aggregation and evaluation.

In MRIs, the type is specified with its short name: counter (c), set (s), distribution (d), and gauge (g). See MetricType for more information.

namespace: MetricNamespace

The namespace for this metric.

In statsd submissions payloads, the namespace is optional and defaults to "custom". Otherwise, the namespace must be declared explicitly.

Note that in Sentry the namespace is also referred to as “use case” or “usecase”. There is a list of known and enabled namespaces. Metrics of unknown or disabled namespaces are dropped during ingestion.

name: Cow<'a, str>

The display name of the metric in the allowed character set.

unit: MetricUnit

The verbatim unit name of the metric value.

The unit is optional and defaults to MetricUnit::None ("none").

Implementations

impl<'a> MetricResourceIdentifier<'a>

pub fn parse(name: &'a str) -> Result<Self, ParseMetricError>

Parses and validates an MRI.

pub fn parse_with_type( string: &'a str, ty: MetricType, ) -> Result<Self, ParseMetricError>

Parses an MRI from a string and a separate type.

The given string must be a part of the MRI, including the following components:

• (optional) The namespace. If missing, it is defaulted to "custom"
• (required) The metric name.
• (optional) The unit. If missing, it is defaulted to “none”.

The metric type is never part of this string and must be supplied separately.

pub fn into_owned(self) -> MetricResourceIdentifier<'static>

Converts the MRI into an owned version with a static lifetime.

Trait Implementations

impl<'a> Clone for MetricResourceIdentifier<'a>

fn clone(&self) -> MetricResourceIdentifier<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for MetricResourceIdentifier<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MetricResourceIdentifier<'static>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for MetricResourceIdentifier<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Hash for MetricResourceIdentifier<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for MetricResourceIdentifier<'a>

fn eq(&self, other: &MetricResourceIdentifier<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for MetricResourceIdentifier<'_>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Eq for MetricResourceIdentifier<'a>

impl<'a> StructuralPartialEq for MetricResourceIdentifier<'a>