Use FiniteF64 to simplify the code

getsentry · phacops · May 14, 2024 · May 13, 2024 · May 13, 2024 · May 14, 2024
commit bc5f39c6a0e8aead49d3b5a324ba21c50714b98c
@@ -20,6 +20,7 @@ itertools = { workspace = true }
 relay-base-schema = { workspace = true }
 relay-event-schema = { workspace = true }
 relay-log = { workspace = true }
+relay-metrics = { workspace = true }
 relay-protocol = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }

@@ -11,9 +11,11 @@
 //!
 use std::collections::{BTreeMap, HashSet};
 
-use relay_event_schema::protocol::EventId;
 use serde::{Deserialize, Serialize};
 
+use relay_event_schema::protocol::EventId;
+use relay_metrics::FiniteF64;
+
 use crate::error::ProfileError;
 use crate::measurements::Measurement;
 use crate::sample::{DebugMeta, Frame, ThreadMetadata, Version};
@@ -41,7 +43,7 @@ pub struct ProfileMetadata {
 pub struct Sample {
     /// Unix timestamp in seconds with millisecond precision when the sample
     /// was captured.
-    pub timestamp: f64,
+    pub timestamp: FiniteF64,
     /// Index of the stack in the `stacks` field of the profile.
     pub stack_id: usize,
     /// Thread or queue identifier
@@ -66,7 +68,7 @@ impl ProfileChunk {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Default, Serialize, Deserialize)]
 pub struct ProfileData {
     /// `samples` contains the list of samples referencing a stack and thread identifier.
     /// If 2 stack of frames captured at 2 different timestamps are identical, you're expected to
@@ -96,7 +98,6 @@ impl ProfileData {
             return Err(ProfileError::NotEnoughSamples);
         }
 
-        // Remove NaN as a side-effect
         self.sort_samples_by_timestamp();
 
         if !self.all_stacks_referenced_by_samples_exist() {
@@ -151,9 +152,7 @@ impl ProfileData {
     }
 
     fn sort_samples_by_timestamp(&mut self) {
-        self.samples.retain(|s| !s.timestamp.is_nan());
-        self.samples
-            .sort_by(|a, b| a.timestamp.partial_cmp(&b.timestamp).unwrap());
+        self.samples.sort_by_key(|s| s.timestamp);
     }
 }
 
@@ -164,7 +163,9 @@ pub fn parse(payload: &[u8]) -> Result<ProfileChunk, ProfileError> {
 
 #[cfg(test)]
 mod tests {
-    use crate::sample::v2::{parse, Frame, ProfileData, Sample};
+    use relay_metrics::FiniteF64;
+
+    use crate::sample::v2::{parse, ProfileData, Sample};
 
     #[test]
     fn test_roundtrip() {
@@ -182,32 +183,28 @@ mod tests {
             samples: vec![
                 Sample {
                     stack_id: 0,
-                    thread_id: "1".to_string(),
-                    timestamp: 2000.0,
-                },
-                Sample {
-                    stack_id: 0,
-                    thread_id: "1".to_string(),
-                    timestamp: 1000.0,
+                    thread_id: "1".into(),
+                    timestamp: FiniteF64::new(2000.0).unwrap(),
                 },
                 Sample {
                     stack_id: 0,
                     thread_id: "1".to_string(),
-                    timestamp: f64::NAN,
+                    timestamp: FiniteF64::new(1000.0).unwrap(),
                 },
             ],
-            stacks: vec![vec![0]],
-            frames: vec![Frame {
-                ..Default::default()
-            }],
-            thread_metadata: Default::default(),
+            ..Default::default()
         };
 
         chunk.sort_samples_by_timestamp();
 
-        let timestamps: Vec<f64> = chunk.samples.iter().map(|s| s.timestamp).collect();
+        let timestamps: Vec<FiniteF64> = chunk.samples.iter().map(|s| s.timestamp).collect();
 
-        assert_eq!(chunk.samples.len(), 2);
-        assert_eq!(timestamps, vec![1000.0, 2000.0]);
+        assert_eq!(
+            timestamps,
+            vec![
+                FiniteF64::new(1000.0).unwrap(),
+                FiniteF64::new(2000.0).unwrap(),
+            ]
+        );
     }
 }