wip

Author: jan-auer

sentry-core/src/cadence.rs

@@ -2,6 +2,8 @@ use std::sync::Arc;
 
 use cadence::MetricSink;
 
+use crate::metrics::{MetricType, MetricValue};
+use crate::units::MetricUnit;
 use crate::{Client, Hub};
 
 /// A [`cadence`] compatible [`MetricSink`].
@@ -28,9 +30,9 @@ impl<S> MetricSink for SentryMetricSink<S>
 where
     S: MetricSink,
 {
-    fn emit(&self, metric: &str) -> std::io::Result<usize> {
-        self.client.add_metric(metric);
-        self.sink.emit(metric)
+    fn emit(&self, string: &str) -> std::io::Result<usize> {
+        parse_and_add(string, &self.client); // Ignore error for now
+        self.sink.emit(string)
     }
 
     fn flush(&self) -> std::io::Result<()> {
@@ -45,6 +47,46 @@ where
     }
 }
 
+fn parse_and_add(string: &str, client: &Client) -> Option<()> {
+    let mut components = string.split('|');
+
+    let (mri_str, value_str) = components.next()?.split_once(':')?;
+    let (name, unit) = match mri_str.split_once('@') {
+        Some((name, unit_str)) => (name, unit_str.parse().ok()?),
+        None => (mri_str, MetricUnit::None),
+    };
+
+    let ty = components.next().and_then(|s| s.parse().ok())?;
+    let value = match ty {
+        MetricType::Counter => MetricValue::Counter(value_str.parse().ok()?),
+        MetricType::Distribution => MetricValue::Distribution(value_str.parse().ok()?),
+        MetricType::Set => MetricValue::Set(value_str.parse().ok()?),
+        MetricType::Gauge => MetricValue::Gauge(value_str.parse().ok()?),
+    };
+
+    let mut builder = client.add_metric(name.to_owned(), value);
+    builder.with_unit(unit);
+
+    for component in components {
+        match component.chars().next() {
+            Some('#') => {
+                for pair in string.get(1..)?.split(',') {
+                    let mut key_value = pair.splitn(2, ':');
+
+                    let key = key_value.next()?.to_owned();
+                    let value = key_value.next().unwrap_or_default().to_owned();
+
+                    builder.with_tag(key, value);
+                }
+            }
+            _ => (),
+        }
+    }
+
+    builder.finish();
+    Some(())
+}
+
 #[cfg(test)]
 mod tests {
     use cadence::{Counted, Distributed};

sentry-core/src/client.rs

@@ -12,7 +12,7 @@ use sentry_types::random_uuid;
 
 use crate::constants::SDK_INFO;
 #[cfg(feature = "UNSTABLE_metrics")]
-use crate::metrics::MetricAggregator;
+use crate::metrics::{self, MetricAggregator};
 use crate::protocol::{ClientSdkInfo, Event};
 use crate::session::SessionFlusher;
 use crate::types::{Dsn, Uuid};
@@ -323,9 +323,15 @@ impl Client {
     }
 
     #[cfg(feature = "UNSTABLE_metrics")]
-    pub(crate) fn add_metric(&self, metric: &str) {
+    pub(crate) fn add_metric(
+        &self,
+        name: impl Into<metrics::MetricStr>,
+        value: metrics::MetricValue,
+    ) -> metrics::MetricBuilder<'_> {
         if let Some(ref aggregator) = *self.metric_aggregator.read().unwrap() {
-            aggregator.add(metric)
+            aggregator.add(name, value)
+        } else {
+            metrics::MetricBuilder::dangling()
         }
     }
 

sentry-core/src/lib.rs

@@ -147,6 +147,8 @@ mod hub_impl;
 mod metrics;
 #[cfg(feature = "client")]
 mod session;
+#[cfg(all(feature = "client", feature = "UNSTABLE_metrics"))]
+mod units;
 #[cfg(all(feature = "client", feature = "UNSTABLE_cadence"))]
 pub use crate::cadence::SentryMetricSink;
 #[cfg(feature = "client")]