feat: Trim release and environment (#184)

* feat: Trim release and environment

* fix: Linting

Author: untitaker

general/derive/src/lib.rs

@@ -677,6 +677,7 @@ struct FieldAttrs {
     field_name: String,
     required: Option<bool>,
     nonempty: Option<bool>,
+    trim_whitespace: Option<bool>,
     pii: Option<bool>,
     retain: bool,
     match_regex: Option<String>,
@@ -711,6 +712,14 @@ impl FieldAttrs {
             quote!(false)
         };
 
+        let trim_whitespace = if let Some(trim_whitespace) = self.trim_whitespace {
+            quote!(#trim_whitespace)
+        } else if let Some(ref parent_attrs) = inherit_from_field_attrs {
+            quote!(#parent_attrs.trim_whitespace)
+        } else {
+            quote!(false)
+        };
+
         let pii = if let Some(pii) = self.pii {
             quote!(#pii)
         } else if let Some(ref parent_attrs) = inherit_from_field_attrs {
@@ -753,6 +762,7 @@ impl FieldAttrs {
                 name: Some(#field_name),
                 required: #required,
                 nonempty: #nonempty,
+                trim_whitespace: #trim_whitespace,
                 match_regex: #match_regex,
                 max_chars: #max_chars,
                 bag_size: #bag_size,
@@ -872,7 +882,18 @@ fn parse_field_attributes(
                                         other => panic!("Unknown value {}", other),
                                     },
                                     _ => {
-                                        panic!("Got non string literal for required");
+                                        panic!("Got non string literal for nonempty");
+                                    }
+                                }
+                            } else if ident == "trim_whitespace" {
+                                match lit {
+                                    Lit::Str(litstr) => match litstr.value().as_str() {
+                                        "true" => rv.trim_whitespace = Some(true),
+                                        "false" => rv.trim_whitespace = Some(false),
+                                        other => panic!("Unknown value {}", other),
+                                    },
+                                    _ => {
+                                        panic!("Got non string literal for trim_whitespace");
                                     }
                                 }
                             } else if ident == "match_regex" {
@@ -943,6 +964,8 @@ fn parse_field_attributes(
                                         panic!("Got non string literal for legacy_alias");
                                     }
                                 }
+                            } else {
+                                panic!("Unknown argument to metastructure: {}", ident);
                             }
                         }
                         other => {

general/src/processor/attrs.rs

@@ -330,6 +330,8 @@ pub struct FieldAttrs {
     pub required: bool,
     /// If the field should be non-empty.
     pub nonempty: bool,
+    /// Whether to trim whitespace from this string.
+    pub trim_whitespace: bool,
     /// A regex to validate the (string) value against.
     pub match_regex: Option<Regex>,
     /// The maximum char length of this field.
@@ -347,6 +349,7 @@ lazy_static::lazy_static! {
         name: None,
         required: false,
         nonempty: false,
+        trim_whitespace: false,
         match_regex: None,
         max_chars: None,
         bag_size: None,
@@ -360,6 +363,7 @@ lazy_static::lazy_static! {
         name: None,
         required: false,
         nonempty: false,
+        trim_whitespace: false,
         match_regex: None,
         max_chars: None,
         bag_size: None,
@@ -373,6 +377,7 @@ lazy_static::lazy_static! {
         name: None,
         required: false,
         nonempty: false,
+        trim_whitespace: false,
         match_regex: None,
         max_chars: None,
         bag_size: None,

general/src/protocol/event.rs

@@ -241,6 +241,7 @@ pub struct Event {
         max_chars = "tag_value",  // release ends in tag
         match_regex = r"^[^\r\n]*\z",
         required = "false",
+        trim_whitespace = "true",
         nonempty = "true",
         skip_serialization = "empty"
     )]
@@ -257,7 +258,11 @@ pub struct Event {
     pub dist: Annotated<String>,
 
     /// Environment the environment was generated in ("production" or "development").
-    #[metastructure(max_chars = "environment", match_regex = r"^[^\r\n\x0C/]+$")]
+    #[metastructure(
+        max_chars = "environment",
+        match_regex = r"^[^\r\n\x0C/]+$",
+        trim_whitespace = "true"
+    )]
     pub environment: Annotated<String>,
 
     /// Deprecated in favor of tags.

general/src/store/schema.rs

@@ -10,7 +10,8 @@ impl Processor for SchemaProcessor {
         meta: &mut Meta,
         state: &ProcessingState<'_>,
     ) -> ValueAction {
-        verify_value_nonempty(value, meta, &state)
+        value_trim_whitespace(value, meta, &state)
+            .and_then(|| verify_value_nonempty(value, meta, &state))
             .and_then(|| verify_value_pattern(value, meta, &state))
     }
 
@@ -54,6 +55,20 @@ impl Processor for SchemaProcessor {
     }
 }
 
+fn value_trim_whitespace(
+    value: &mut String,
+    _meta: &mut Meta,
+    state: &ProcessingState<'_>,
+) -> ValueAction {
+    if state.attrs().trim_whitespace {
+        let new_value = value.trim().to_owned();
+        value.clear();
+        value.push_str(&new_value);
+    }
+
+    ValueAction::Keep
+}
+
 fn verify_value_nonempty<T>(
     value: &mut T,
     meta: &mut Meta,
@@ -133,7 +148,7 @@ mod tests {
     }
 
     #[test]
-    fn test_release_newlines() {
+    fn test_release_invalid_newlines() {
         use crate::protocol::Event;
 
         let mut event = Annotated::new(Event {
@@ -265,4 +280,22 @@ mod tests {
 
         assert_eq_dbg!(stack, expected);
     }
+
+    #[test]
+    fn test_newlines_release() {
+        use crate::protocol::Event;
+        let mut event = Annotated::new(Event {
+            release: Annotated::new("42\n".to_string().into()),
+            ..Default::default()
+        });
+
+        process_value(&mut event, &mut SchemaProcessor, ProcessingState::root());
+
+        let expected = Annotated::new(Event {
+            release: Annotated::new("42".to_string().into()),
+            ..Default::default()
+        });
+
+        assert_eq_dbg!(expected, event);
+    }
 }