feat(transactions): Adding support for transaction (re)naming rules

CHANGELOG.md

@@ -29,6 +29,7 @@
 - Parse string as number to handle a release bug. ([#1637](https://github.com/getsentry/relay/pull/1637))
 - Expand Profiling's discard reasons. ([#1661](https://github.com/getsentry/relay/pull/1661), [#1685](https://github.com/getsentry/relay/pull/1685))
 - Allow to rate limit profiles on top of transactions. ([#1681](https://github.com/getsentry/relay/pull/1681))
+- Support transaction naming rules. The rules will be currently applied to transactions where the transaction source set to `url`. ([#1695](https://github.com/getsentry/relay/pull/1695))
 
 ## 22.11.0
 

relay-cabi/src/processing.rs

@@ -120,6 +120,7 @@ pub unsafe extern "C" fn relay_store_normalizer_normalize_event(
         breakdowns_config: None,   // only supported in relay
         normalize_user_agent: config.normalize_user_agent,
         normalize_transaction_name: false, // only supported in relay
+        tx_name_rules: &[],                // only supported in relay
         is_renormalize: config.is_renormalize.unwrap_or(false),
     };
     light_normalize_event(&mut event, &light_normalization_config)?;

relay-common/src/utils.rs

@@ -6,45 +6,110 @@ use regex::Regex;
 
 use crate::macros::impl_str_serde;
 
-/// A simple glob matcher.
-///
-/// Supported are `?` for a single char, `*` for all but a slash and
-/// `**` to match with slashes.
-#[derive(Clone)]
-pub struct Glob {
-    value: String,
-    pattern: Regex,
+/// Glob options is used to configure the behaviour underlying regex.
+#[derive(Debug)]
+struct GlobPatternOpts<'g> {
+    star: &'g str,
+    double_star: &'g str,
+    question_mark: &'g str,
 }
 
-impl Glob {
-    /// Creates a new glob from a string.
-    pub fn new(glob: &str) -> Glob {
-        let mut pattern = String::with_capacity(glob.len() + 100);
+/// `GlobBuilder` provides the posibility to fine tune the final [`Glob`], mainly what capture
+/// groups will be enabled in the underlying regex.
+#[derive(Debug)]
+pub struct GlobBuilder<'g> {
+    value: &'g str,
+    opts: GlobPatternOpts<'g>,
+}
+
+impl<'g> GlobBuilder<'g> {
+    /// Create a new builder with all the captures enabled by default.
+    pub fn new(value: &'g str) -> Self {
+        let opts = GlobPatternOpts {
+            star: "([^/]*?)",
+            double_star: "(.*?)",
+            question_mark: "(.)",
+        };
+        Self { value, opts }
+    }
+
+    /// Enable capture groups for `*` in the pattern.
+    pub fn capture_star(mut self, enable: bool) -> Self {
+        if !enable {
+            self.opts.star = "(?:[^/]*?)";
+        }
+        self
+    }
+
+    /// Enable capture groups for `**` in the pattern.
+    pub fn capture_double_star(mut self, enable: bool) -> Self {
+        if !enable {
+            self.opts.double_star = "(?:.*?)";
+        }
+        self
+    }
+
+    /// Enable capture groups for `?` in the pattern.
+    pub fn capture_question_mark(mut self, enable: bool) -> Self {
+        if !enable {
+            self.opts.question_mark = "(?:.)";
+        }
+        self
+    }
+
+    /// Create a new [`Glob`] from this builder.
+    pub fn build(self) -> Glob {
+        let mut pattern = String::with_capacity(&self.value.len() + 100);
         let mut last = 0;
 
         pattern.push('^');
 
         static GLOB_RE: OnceCell<Regex> = OnceCell::new();
         let regex = GLOB_RE.get_or_init(|| Regex::new(r#"\?|\*\*|\*"#).unwrap());
 
-        for m in regex.find_iter(glob) {
-            pattern.push_str(&regex::escape(&glob[last..m.start()]));
+        for m in regex.find_iter(self.value) {
+            pattern.push_str(&regex::escape(&self.value[last..m.start()]));
             match m.as_str() {
-                "?" => pattern.push_str("(.)"),
-                "**" => pattern.push_str("(.*?)"),
-                "*" => pattern.push_str("([^/]*?)"),
+                "?" => pattern.push_str(self.opts.question_mark),
+                "**" => pattern.push_str(self.opts.double_star),
+                "*" => pattern.push_str(self.opts.star),
                 _ => {}
             }
             last = m.end();
         }
-        pattern.push_str(&regex::escape(&glob[last..]));
+        pattern.push_str(&regex::escape(&self.value[last..]));
         pattern.push('$');
 
         Glob {
-            value: glob.to_string(),
+            value: self.value.to_owned(),
             pattern: Regex::new(&pattern).unwrap(),
         }
     }
+}
+
+/// A simple glob matcher.
+///
+/// Supported are `?` for a single char, `*` for all but a slash and
+/// `**` to match with slashes.
+#[derive(Clone)]
+pub struct Glob {
+    value: String,
+    pattern: Regex,
+}
+
+impl Glob {
+    /// Creates the [`GlobBuilder`], which can be fine-tunned using helper methods.
+    pub fn builder(glob: &'_ str) -> GlobBuilder {
+        GlobBuilder::new(glob)
+    }
+
+    /// Creates a new glob from a string.
+    ///
+    /// All the glob patterns (wildcards) are enabled in the captures, and can be returned by
+    /// `matches` function.
+    pub fn new(glob: &str) -> Glob {
+        GlobBuilder::new(glob).build()
+    }
 
     /// Returns the pattern as str.
     pub fn pattern(&self) -> &str {
@@ -56,6 +121,26 @@ impl Glob {
         self.pattern.is_match(value)
     }
 
+    /// Currently support replacing only all `*` in the input string with provided replacement.
+    /// If no match is found, then a copy of the string is returned unchanged.
+    pub fn apply(&self, input: &str, replacement: &str) -> String {
+        let mut output = String::new();
+        let mut current = 0;
+
+        for caps in self.pattern.captures_iter(input) {
+            // Create the iter on subcaptures and ignore the first capture, since this is always
+            // the entire string.
+            for cap in caps.iter().flatten().skip(1) {
+                output.push_str(&input[current..cap.start()]);
+                output.push_str(replacement);
+                current = cap.end();
+            }
+        }
+
+        output.push_str(&input[current..]);
+        output
+    }
+
     /// Checks if the value matches and returns the wildcard matches.
     pub fn matches<'t>(&self, value: &'t str) -> Option<Vec<&'t str>> {
         self.pattern.captures(value).map(|caps| {
@@ -67,6 +152,14 @@ impl Glob {
     }
 }
 
+impl PartialEq for Glob {
+    fn eq(&self, other: &Self) -> bool {
+        self.value == other.value
+    }
+}
+
+impl Eq for Glob {}
+
 impl str::FromStr for Glob {
     type Err = ();
 
@@ -167,6 +260,26 @@ mod tests {
         let g = Glob::new("api/**/store/");
         assert!(g.is_match("api/some/stuff/here/store/"));
         assert!(g.is_match("api/some/store/"));
+
+        let g = Glob::new("/api/*/stuff/**");
+        assert!(g.is_match("/api/some/stuff/here/store/"));
+        assert!(!g.is_match("/api/some/store/"));
+    }
+
+    #[test]
+    fn test_glob_replace() {
+        let g = Glob::builder("/foo/*/bar/**")
+            .capture_star(true)
+            .capture_double_star(false)
+            .capture_question_mark(false)
+            .build();
+
+        assert_eq!(
+            g.apply("/foo/some/bar/here/store", "*"),
+            "/foo/*/bar/here/store"
+        );
+        assert_eq!(g.apply("/foo/testing/bar/", "*"), "/foo/*/bar/");
+        assert_eq!(g.apply("/foo/testing/1/", "*"), "/foo/testing/1/");
     }
 
     #[test]

relay-general/src/protocol/transaction.rs

@@ -1,12 +1,15 @@
 use std::fmt;
 use std::str::FromStr;
 
+use serde::{Deserialize, Serialize};
+
 use crate::processor::ProcessValue;
 use crate::protocol::Timestamp;
 use crate::types::{Annotated, Empty, ErrorKind, FromValue, IntoValue, SkipSerialization, Value};
 
 /// Describes how the name of the transaction was determined.
-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
 #[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
 #[cfg_attr(feature = "jsonschema", schemars(rename_all = "kebab-case"))]
 pub enum TransactionSource {
@@ -20,6 +23,8 @@ pub enum TransactionSource {
     View,
     /// Named after a software component, such as a function or class name.
     Component,
+    /// The transaction name was updated to remove high cardinality parts.
+    Sanitized,
     /// Name of a background task (e.g. a Celery task).
     Task,
     /// This is the default value set by Relay for legacy SDKs.
@@ -37,6 +42,7 @@ impl TransactionSource {
             Self::Route => "route",
             Self::View => "view",
             Self::Component => "component",
+            Self::Sanitized => "sanitized",
             Self::Task => "task",
             Self::Unknown => "unknown",
             Self::Other(ref s) => s,
@@ -54,6 +60,7 @@ impl FromStr for TransactionSource {
             "route" => Ok(Self::Route),
             "view" => Ok(Self::View),
             "component" => Ok(Self::Component),
+            "sanitized" => Ok(Self::Sanitized),
             "task" => Ok(Self::Task),
             "unknown" => Ok(Self::Unknown),
             s => Ok(Self::Other(s.to_owned())),

relay-general/src/store/normalize.rs

@@ -12,7 +12,7 @@ use smallvec::SmallVec;
 
 use relay_common::{DurationUnit, FractionUnit, MetricUnit};
 
-use super::{schema, transactions, BreakdownsConfig};
+use super::{schema, transactions, BreakdownsConfig, TransactionNameRule};
 use crate::processor::{MaxChars, ProcessValue, ProcessingState, Processor};
 use crate::protocol::{
     self, AsPair, Breadcrumb, ClientSdkInfo, Context, Contexts, DebugImage, Event, EventId,
@@ -664,6 +664,7 @@ pub struct LightNormalizationConfig<'a> {
     pub breakdowns_config: Option<&'a BreakdownsConfig>,
     pub normalize_user_agent: Option<bool>,
     pub normalize_transaction_name: bool,
+    pub tx_name_rules: &'a [TransactionNameRule],
     pub is_renormalize: bool,
 }
 
@@ -680,8 +681,10 @@ pub fn light_normalize_event(
         // (internally noops for non-transaction events).
         // TODO: Parts of this processor should probably be a filter so we
         // can revert some changes to ProcessingAction
-        let mut transactions_processor =
-            transactions::TransactionsProcessor::new(config.normalize_transaction_name);
+        let mut transactions_processor = transactions::TransactionsProcessor::new(
+            config.normalize_transaction_name,
+            config.tx_name_rules,
+        );
         transactions_processor.process_event(event, meta, ProcessingState::root())?;
 
         // Check for required and non-empty values

relay-general/src/store/transactions/mod.rs

@@ -0,0 +1,5 @@
+mod processor;
+mod rules;
+
+pub use processor::*;
+pub use rules::*;