feat: Preliminary work to integrate Performance Monitoring (#276)

aramperes · web-flow · commit c8ef5fecea34 · 2020-10-17T12:42:38.000+02:00
diff --git a/sentry-types/src/protocol/envelope.rs b/sentry-types/src/protocol/envelope.rs
@@ -4,6 +4,7 @@ use uuid::Uuid;
 
 use super::v7::Event;
 use super::v7::SessionUpdate;
+use super::v7::Transaction;
 
 /// An Envelope Item.
 ///
@@ -22,9 +23,14 @@ pub enum EnvelopeItem {
     /// See the [Session Item documentation](https://develop.sentry.dev/sdk/envelopes/#session)
     /// for more details.
     SessionUpdate(SessionUpdate<'static>),
-    /* TODO:
-     * * Attachment,
-     * etc… */
+    /// A Transaction Item.
+    ///
+    /// See the [Transaction Item documentation](https://develop.sentry.dev/sdk/envelopes/#transaction)
+    /// for more details.
+    Transaction(Transaction<'static>),
+    // TODO:
+    // * Attachment,
+    // etc…
 }
 
 impl From<Event<'static>> for EnvelopeItem {
@@ -39,6 +45,12 @@ impl From<SessionUpdate<'static>> for EnvelopeItem {
     }
 }
 
+impl From<Transaction<'static>> for EnvelopeItem {
+    fn from(session: Transaction<'static>) -> Self {
+        EnvelopeItem::Transaction(session)
+    }
+}
+
 /// An Iterator over the items of an Envelope.
 #[derive(Clone)]
 pub struct EnvelopeItemIter<'s> {
@@ -82,6 +94,8 @@ impl Envelope {
         if self.event_id.is_none() {
             if let EnvelopeItem::Event(ref event) = item {
                 self.event_id = Some(event.event_id);
+            } else if let EnvelopeItem::Transaction(ref transaction) = item {
+                self.event_id = Some(transaction.event_id);
             }
         }
         self.items.push(item);
@@ -136,10 +150,14 @@ impl Envelope {
                 EnvelopeItem::SessionUpdate(session) => {
                     serde_json::to_writer(&mut item_buf, session)?
                 }
+                EnvelopeItem::Transaction(transaction) => {
+                    serde_json::to_writer(&mut item_buf, transaction)?
+                }
             }
             let item_type = match item {
                 EnvelopeItem::Event(_) => "event",
                 EnvelopeItem::SessionUpdate(_) => "session",
+                EnvelopeItem::Transaction(_) => "transaction",
             };
             writeln!(
                 writer,
@@ -164,12 +182,20 @@ impl From<Event<'static>> for Envelope {
     }
 }
 
+impl From<Transaction<'static>> for Envelope {
+    fn from(transaction: Transaction<'static>) -> Self {
+        let mut envelope = Self::default();
+        envelope.add_item(transaction);
+        envelope
+    }
+}
+
 #[cfg(test)]
 mod test {
     use chrono::{DateTime, Utc};
 
     use super::*;
-    use crate::protocol::v7::{SessionAttributes, SessionStatus};
+    use crate::protocol::v7::{SessionAttributes, SessionStatus, Span};
 
     fn to_str(envelope: Envelope) -> String {
         let mut vec = Vec::new();
@@ -229,6 +255,34 @@ mod test {
             r#"{}
 {"type":"session","length":222}
 {"sid":"22d00b3f-d1b1-4b5d-8d20-49d138cd8a9c","did":"foo@bar.baz","started":"2020-07-20T14:51:14.296Z","init":true,"duration":1.234,"status":"ok","errors":123,"attrs":{"release":"foo-bar@1.2.3","environment":"production"}}
+"#
+        )
+    }
+
+    #[test]
+    fn test_transaction() {
+        let event_id = Uuid::parse_str("22d00b3f-d1b1-4b5d-8d20-49d138cd8a9c").unwrap();
+        let span_id = Uuid::parse_str("d42cee9f-c3e7-4f5c-ada9-47ab601a14d2").unwrap();
+        let trace_id = Uuid::parse_str("335e53d6-1447-4acc-9f89-e632b776cc28").unwrap();
+        let start_timestamp = "2020-07-20T14:51:14.296Z".parse::<DateTime<Utc>>().unwrap();
+        let spans = vec![Span {
+            span_id,
+            trace_id,
+            start_timestamp,
+            ..Default::default()
+        }];
+        let transaction = Transaction {
+            event_id,
+            start_timestamp,
+            spans,
+            ..Default::default()
+        };
+        let envelope: Envelope = transaction.into();
+        assert_eq!(
+            to_str(envelope),
+            r#"{"event_id":"22d00b3f-d1b1-4b5d-8d20-49d138cd8a9c"}
+{"type":"transaction","length":216}
+{"event_id":"22d00b3fd1b14b5d8d2049d138cd8a9c","start_timestamp":1595256674.296,"spans":[{"span_id":"d42cee9fc3e74f5cada947ab601a14d2","trace_id":"335e53d614474acc9f89e632b776cc28","start_timestamp":1595256674.296}]}
 "#
         )
     }
diff --git a/sentry-types/src/protocol/v7.rs b/sentry-types/src/protocol/v7.rs
@@ -1038,6 +1038,7 @@ pub struct ClientSdkPackage {
 /// to `Context`.
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
 #[serde(rename_all = "snake_case", tag = "type")]
+#[non_exhaustive]
 pub enum Context {
     /// Device data.
     Device(Box<DeviceContext>),
@@ -1049,6 +1050,8 @@ pub enum Context {
     App(Box<AppContext>),
     /// Web browser data.
     Browser(Box<BrowserContext>),
+    /// Tracing data.
+    Trace(Box<TraceContext>),
     /// Generic other context data.
     #[serde(rename = "unknown")]
     Other(Map<String, Value>),
@@ -1063,6 +1066,7 @@ impl Context {
             Context::Runtime(..) => "runtime",
             Context::App(..) => "app",
             Context::Browser(..) => "browser",
+            Context::Trace(..) => "trace",
             Context::Other(..) => "unknown",
         }
     }
@@ -1217,6 +1221,29 @@ pub struct BrowserContext {
     pub other: Map<String, Value>,
 }
 
+/// Holds information about a tracing event.
+#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq)]
+pub struct TraceContext {
+    /// The ID of the trace event
+    #[serde(default = "event::default_id", serialize_with = "event::serialize_id")]
+    pub span_id: Uuid,
+    /// Determines which trace the transaction belongs to.
+    #[serde(default = "event::default_id", serialize_with = "event::serialize_id")]
+    pub trace_id: Uuid,
+    /// Determines the parent of this transaction if any.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parent_span_id: Option<String>,
+    /// Short code identifying the type of operation the transaction is measuring.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub op: Option<String>,
+    /// Human readable detail description.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    /// Describes the status of the span (e.g. `ok`, `cancelled`, etc.)
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+}
+
 macro_rules! into_context {
     ($kind:ident, $ty:ty) => {
         impl From<$ty> for Context {
@@ -1232,6 +1259,7 @@ into_context!(Device, DeviceContext);
 into_context!(Os, OsContext);
 into_context!(Runtime, RuntimeContext);
 into_context!(Browser, BrowserContext);
+into_context!(Trace, TraceContext);
 
 mod event {
     use super::*;
@@ -1454,3 +1482,169 @@ impl<'a> fmt::Display for Event<'a> {
         write!(f, "Event(id: {}, ts: {})", self.event_id, self.timestamp)
     }
 }
+
+/// Represents a tracing span.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
+pub struct Span {
+    /// The ID of the span
+    #[serde(default = "event::default_id", serialize_with = "event::serialize_id")]
+    pub span_id: Uuid,
+    /// Determines which trace the span belongs to.
+    #[serde(default = "event::default_id", serialize_with = "event::serialize_id")]
+    pub trace_id: Uuid,
+    /// Determines the parent of this span, if any.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parent_span_id: Option<String>,
+    /// Determines whether this span is generated in the same process as its parent, if any.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub same_process_as_parent: Option<bool>,
+    /// Short code identifying the type of operation the span is measuring.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub op: Option<String>,
+    /// Longer description of the span's operation, which uniquely identifies the span
+    /// but is consistent across instances of the span.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    /// The timestamp at the measuring of the span finished.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<DateTime<Utc>>,
+    /// The timestamp at the measuring of the span started.
+    #[serde(default = "event::default_timestamp", with = "ts_seconds_float")]
+    pub start_timestamp: DateTime<Utc>,
+    /// Describes the status of the span (e.g. `ok`, `cancelled`, etc.)
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    /// Optional tags to be attached to the span.
+    #[serde(default, skip_serializing_if = "Map::is_empty")]
+    pub tags: Map<String, String>,
+    /// Optional extra information to be sent with the span.
+    #[serde(default, skip_serializing_if = "Map::is_empty")]
+    pub data: Map<String, Value>,
+}
+
+impl Default for Span {
+    fn default() -> Self {
+        Span {
+            span_id: event::default_id(),
+            trace_id: event::default_id(),
+            timestamp: Default::default(),
+            tags: Default::default(),
+            start_timestamp: event::default_timestamp(),
+            description: Default::default(),
+            status: Default::default(),
+            parent_span_id: Default::default(),
+            same_process_as_parent: Default::default(),
+            op: Default::default(),
+            data: Default::default(),
+        }
+    }
+}
+
+impl Span {
+    /// Creates a new span with the current timestamp and random id.
+    pub fn new() -> Span {
+        Default::default()
+    }
+
+    /// Finalizes the span.
+    pub fn finish(&mut self) {
+        self.timestamp = Some(Utc::now());
+    }
+}
+
+impl fmt::Display for Span {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "Span(id: {}, ts: {})",
+            self.span_id, self.start_timestamp
+        )
+    }
+}
+
+/// Represents a tracing transaction.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
+pub struct Transaction<'a> {
+    /// The ID of the event
+    #[serde(default = "event::default_id", serialize_with = "event::serialize_id")]
+    pub event_id: Uuid,
+    /// The transaction name.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    /// Optional tags to be attached to the event.
+    #[serde(default, skip_serializing_if = "Map::is_empty")]
+    pub tags: Map<String, String>,
+    /// SDK metadata
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sdk: Option<Cow<'a, ClientSdkInfo>>,
+    /// A platform identifier for this event.
+    #[serde(
+        default = "event::default_platform",
+        skip_serializing_if = "event::is_default_platform"
+    )]
+    pub platform: Cow<'a, str>,
+    /// The end time of the transaction.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<DateTime<Utc>>,
+    /// The start time of the transaction.
+    #[serde(default = "event::default_timestamp", with = "ts_seconds_float")]
+    pub start_timestamp: DateTime<Utc>,
+    /// The collection of finished spans part of this transaction.
+    pub spans: Vec<Span>,
+    /// Optional contexts.
+    #[serde(default, skip_serializing_if = "Map::is_empty")]
+    pub contexts: Map<String, Context>,
+}
+
+impl<'a> Default for Transaction<'a> {
+    fn default() -> Self {
+        Transaction {
+            event_id: event::default_id(),
+            name: Default::default(),
+            tags: Default::default(),
+            sdk: Default::default(),
+            platform: event::default_platform(),
+            timestamp: Default::default(),
+            start_timestamp: event::default_timestamp(),
+            spans: Default::default(),
+            contexts: Default::default(),
+        }
+    }
+}
+
+impl<'a> Transaction<'a> {
+    /// Creates a new span transaction the current timestamp and random id.
+    pub fn new() -> Transaction<'a> {
+        Default::default()
+    }
+
+    /// Creates a fully owned version of the transaction.
+    pub fn into_owned(self) -> Transaction<'static> {
+        Transaction {
+            event_id: self.event_id,
+            name: self.name,
+            tags: self.tags,
+            sdk: self.sdk.map(|x| Cow::Owned(x.into_owned())),
+            platform: Cow::Owned(self.platform.into_owned()),
+            timestamp: self.timestamp,
+            start_timestamp: self.start_timestamp,
+            spans: self.spans,
+            contexts: self.contexts,
+        }
+    }
+
+    /// Finalizes the transaction to be dispatched.
+    pub fn finish(&mut self) {
+        self.timestamp = Some(Utc::now());
+    }
+}
+
+impl<'a> fmt::Display for Transaction<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "Transaction(id: {}, ts: {})",
+            self.event_id, self.start_timestamp
+        )
+    }
+}
