feat(dynamic-sampling): Introduce a new rule to raise the floor of the sample rate (#4801)

Every project can define a minimum ("floor") sample rate. Relay will
evaluate two rules for each transaction for the base sample rate.

trace rule: as usual.
floor rule: ensures the minimum rate for the project.

Relay should base its dynamic sampling decision on the larger of the two
rates.
Balancing rules should be applied to the floor rule to apply consistent
up-sampling of rare transactions

Example

```
Trace sample rate: 0.05
Floor Rule: 0.5
Transaction Rule: x * 1.5
```

Result:
```
Base rate: 0.5 > 0.05 => 0.5
After applying balancing rules: 
0.5 * 1.5 = 0.75
```

--- 

Only the first rule is applied to make sure local transaction based
rules apply before trace based rules.

Refs: TET-565

Author: Dav1dde

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 **Features**:
 
+- Implements a minimum sample rate dynamic sampling rule. ([#4801](https://github.com/getsentry/relay/pull/4801))
 - Convert NEL reports into logs. ([#4813](https://github.com/getsentry/relay/pull/4813)
 - Add parsing for _Nintendo Switch_ to populate `os.name="Nintendo OS"`. ([#4821](https://github.com/getsentry/relay/pull/4821))
 

relay-sampling/src/config.rs

@@ -162,6 +162,17 @@ pub enum SamplingValue {
         /// The limit of how many times this rule will be sampled before this rule is invalid.
         limit: i64,
     },
+
+    /// A minimum sample rate.
+    ///
+    /// The sample rate specified in the rule will be used as a minimum over the otherwise used
+    /// sample rate.
+    ///
+    /// Only the first matching minimum sample rate will be applied.
+    MinimumSampleRate {
+        /// The minimum sample rate used to raise the chosen sample rate.
+        value: f64,
+    },
 }
 
 /// Defines what a dynamic sampling rule applies to.

relay-sampling/src/evaluation.rs

@@ -158,6 +158,7 @@ pub struct SamplingEvaluator<'a> {
     now: DateTime<Utc>,
     rule_ids: Vec<RuleId>,
     factor: f64,
+    minimum_sample_rate: Option<f64>,
     reservoir: Option<&'a ReservoirEvaluator<'a>>,
 }
 
@@ -168,6 +169,7 @@ impl<'a> SamplingEvaluator<'a> {
             now,
             rule_ids: vec![],
             factor: 1.0,
+            minimum_sample_rate: None,
             reservoir: Some(reservoir),
         }
     }
@@ -178,6 +180,7 @@ impl<'a> SamplingEvaluator<'a> {
             now,
             rule_ids: vec![],
             factor: 1.0,
+            minimum_sample_rate: None,
             reservoir: None,
         }
     }
@@ -232,7 +235,8 @@ impl<'a> SamplingEvaluator<'a> {
             }
             SamplingValue::SampleRate { value } => {
                 let sample_rate = rule.apply_decaying_fn(value, self.now)?;
-                let adjusted = (sample_rate * self.factor).clamp(0.0, 1.0);
+                let minimum_sample_rate = self.minimum_sample_rate.unwrap_or(0.0);
+                let adjusted = (sample_rate.max(minimum_sample_rate) * self.factor).clamp(0.0, 1.0);
 
                 self.rule_ids.push(rule.id);
                 Some(adjusted)
@@ -252,6 +256,13 @@ impl<'a> SamplingEvaluator<'a> {
                 // If the reservoir has not yet reached its limit, we want to sample 100%.
                 Some(1.0)
             }
+            SamplingValue::MinimumSampleRate { value } => {
+                if self.minimum_sample_rate.is_none() {
+                    self.minimum_sample_rate = Some(rule.apply_decaying_fn(value, self.now)?);
+                    self.rule_ids.push(rule.id);
+                }
+                None
+            }
         }
     }
 }
@@ -537,6 +548,30 @@ mod tests {
         assert_eq!(get_sampling_match(&rules, &dsc).await.sample_rate(), 0.1);
     }
 
+    #[tokio::test]
+    async fn test_minimum_sample_rate() {
+        let rules = simple_sampling_rules(vec![
+            (RuleCondition::all(), SamplingValue::Factor { value: 1.5 }),
+            (
+                RuleCondition::all(),
+                SamplingValue::MinimumSampleRate { value: 0.5 },
+            ),
+            // Only the first matching minimum is applied.
+            (
+                RuleCondition::all(),
+                SamplingValue::MinimumSampleRate { value: 1.0 },
+            ),
+            (
+                RuleCondition::all(),
+                SamplingValue::SampleRate { value: 0.05 },
+            ),
+        ]);
+        let dsc = mocked_dsc_with_getter_values(vec![]);
+
+        // max(0.05, 0.5) * 1.5 = 0.75
+        assert_eq!(get_sampling_match(&rules, &dsc).await.sample_rate(), 0.75);
+    }
+
     fn mocked_sampling_rule() -> SamplingRule {
         SamplingRule {
             condition: RuleCondition::all(),