sentry_types/protocol/
v7.rs

Help
1//! The current latest sentry protocol version.
2//!
3//! Most constructs in the protocol map directly to types here but some
4//! cleanup by renaming attributes has been applied.  The idea here is that
5//! a future sentry protocol will be a cleanup of the old one and is mapped
6//! to similar values on the rust side.
7
8use std::borrow::Cow;
9use std::cmp;
10use std::convert::TryFrom;
11use std::fmt;
12use std::iter::FromIterator;
13use std::net::{AddrParseError, IpAddr};
14use std::ops;
15use std::str;
16use std::time::SystemTime;
17
18use self::debugid::{CodeId, DebugId};
19use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
20use thiserror::Error;
21
22pub use url::Url;
23pub use uuid::Uuid;
24
25use crate::utils::{ts_rfc3339_opt, ts_seconds_float};
26
27pub use super::attachment::*;
28pub use super::envelope::*;
29pub use super::monitor::*;
30pub use super::session::*;
31
32/// An arbitrary (JSON) value.
33pub mod value {
34    pub use serde_json::value::{from_value, to_value, Index, Map, Number, Value};
35}
36
37/// The internally used arbitrary data map type.
38pub mod map {
39    pub use std::collections::btree_map::{BTreeMap as Map, *};
40}
41
42/// Represents a debug ID.
43pub mod debugid {
44    pub use debugid::{BreakpadFormat, CodeId, DebugId, ParseDebugIdError};
45}
46
47/// An arbitrary (JSON) value.
48pub use self::value::Value;
49
50/// The internally used map type.
51pub use self::map::Map;
52
53/// A wrapper type for collections with attached meta data.
54///
55/// The JSON payload can either directly be an array or an object containing a `values` field and
56/// arbitrary other fields. All other fields will be collected into `Values::data` when
57/// deserializing and re-serialized in the same place. The shorthand array notation is always
58/// reserialized as object.
59#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
60pub struct Values<T> {
61    /// The values of the collection.
62    pub values: Vec<T>,
63}
64
65impl<T> Values<T> {
66    /// Creates an empty values struct.
67    pub fn new() -> Values<T> {
68        Values { values: Vec::new() }
69    }
70
71    /// Checks whether this struct is empty in both values and data.
72    pub fn is_empty(&self) -> bool {
73        self.values.is_empty()
74    }
75}
76
77impl<T> Default for Values<T> {
78    fn default() -> Self {
79        // Default implemented manually even if <T> does not impl Default.
80        Values::new()
81    }
82}
83
84impl<T> From<Vec<T>> for Values<T> {
85    fn from(values: Vec<T>) -> Self {
86        Values { values }
87    }
88}
89
90impl<T> AsRef<[T]> for Values<T> {
91    fn as_ref(&self) -> &[T] {
92        &self.values
93    }
94}
95
96impl<T> AsMut<Vec<T>> for Values<T> {
97    fn as_mut(&mut self) -> &mut Vec<T> {
98        &mut self.values
99    }
100}
101
102impl<T> ops::Deref for Values<T> {
103    type Target = [T];
104
105    fn deref(&self) -> &Self::Target {
106        &self.values
107    }
108}
109
110impl<T> ops::DerefMut for Values<T> {
111    fn deref_mut(&mut self) -> &mut Self::Target {
112        &mut self.values
113    }
114}
115
116impl<T> FromIterator<T> for Values<T> {
117    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
118        Vec::<T>::from_iter(iter).into()
119    }
120}
121
122impl<T> Extend<T> for Values<T> {
123    fn extend<I>(&mut self, iter: I)
124    where
125        I: IntoIterator<Item = T>,
126    {
127        self.values.extend(iter)
128    }
129}
130
131impl<'a, T> IntoIterator for &'a mut Values<T> {
132    type Item = <&'a mut Vec<T> as IntoIterator>::Item;
133    type IntoIter = <&'a mut Vec<T> as IntoIterator>::IntoIter;
134
135    fn into_iter(self) -> Self::IntoIter {
136        self.values.iter_mut()
137    }
138}
139
140impl<'a, T> IntoIterator for &'a Values<T> {
141    type Item = <&'a Vec<T> as IntoIterator>::Item;
142    type IntoIter = <&'a Vec<T> as IntoIterator>::IntoIter;
143
144    fn into_iter(self) -> Self::IntoIter {
145        self.values.iter()
146    }
147}
148
149impl<T> IntoIterator for Values<T> {
150    type Item = <Vec<T> as IntoIterator>::Item;
151    type IntoIter = <Vec<T> as IntoIterator>::IntoIter;
152
153    fn into_iter(self) -> Self::IntoIter {
154        self.values.into_iter()
155    }
156}
157
158/// Represents a log entry message.
159///
160/// A log message is similar to the `message` attribute on the event itself but
161/// can additionally hold optional parameters.
162#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq)]
163pub struct LogEntry {
164    /// The log message with parameters replaced by `%s`
165    pub message: String,
166    /// Positional parameters to be inserted into the log entry.
167    #[serde(default, skip_serializing_if = "Vec::is_empty")]
168    pub params: Vec<Value>,
169}
170
171/// Represents a frame.
172#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq)]
173pub struct Frame {
174    /// The name of the function is known.
175    ///
176    /// Note that this might include the name of a class as well if that makes
177    /// sense for the language.
178    #[serde(default, skip_serializing_if = "Option::is_none")]
179    pub function: Option<String>,
180    /// The potentially mangled name of the symbol as it appears in an executable.
181    ///
182    /// This is different from a function name by generally being the mangled
183    /// name that appears natively in the binary.  This is relevant for languages
184    /// like Swift, C++ or Rust.
185    #[serde(default, skip_serializing_if = "Option::is_none")]
186    pub symbol: Option<String>,
187    /// The name of the module the frame is contained in.
188    ///
189    /// Note that this might also include a class name if that is something the
190    /// language natively considers to be part of the stack (for instance in Java).
191    #[serde(default, skip_serializing_if = "Option::is_none")]
192    pub module: Option<String>,
193    /// The name of the package that contains the frame.
194    ///
195    /// For instance this can be a dylib for native languages, the name of the jar
196    /// or .NET assembly.
197    #[serde(default, skip_serializing_if = "Option::is_none")]
198    pub package: Option<String>,
199    /// The filename (basename only).
200    #[serde(default, skip_serializing_if = "Option::is_none")]
201    pub filename: Option<String>,
202    /// If known the absolute path.
203    #[serde(default, skip_serializing_if = "Option::is_none")]
204    pub abs_path: Option<String>,
205    /// The line number if known.
206    #[serde(default, skip_serializing_if = "Option::is_none")]
207    pub lineno: Option<u64>,
208    /// The column number if known.
209    #[serde(default, skip_serializing_if = "Option::is_none")]
210    pub colno: Option<u64>,
211    /// The sources of the lines leading up to the current line.
212    #[serde(default, skip_serializing_if = "Vec::is_empty")]
213    pub pre_context: Vec<String>,
214    /// The current line as source.
215    #[serde(default, skip_serializing_if = "Option::is_none")]
216    pub context_line: Option<String>,
217    /// The sources of the lines after the current line.
218    #[serde(default, skip_serializing_if = "Vec::is_empty")]
219    pub post_context: Vec<String>,
220    /// In-app indicator.
221    #[serde(default, skip_serializing_if = "Option::is_none")]
222    pub in_app: Option<bool>,
223    /// Optional local variables.
224    #[serde(default, skip_serializing_if = "Map::is_empty")]
225    pub vars: Map<String, Value>,
226    /// If known the location of the image.
227    #[serde(default, skip_serializing_if = "Option::is_none")]
228    pub image_addr: Option<Addr>,
229    /// If known the location of the instruction.
230    #[serde(default, skip_serializing_if = "Option::is_none")]
231    pub instruction_addr: Option<Addr>,
232    /// If known the location of symbol.
233    #[serde(default, skip_serializing_if = "Option::is_none")]
234    pub symbol_addr: Option<Addr>,
235    /// Optionally changes the addressing mode. The default value is the same as
236    /// `"abs"` which means absolute referencing. This can also be set to
237    /// `"rel:DEBUG_ID"` or `"rel:IMAGE_INDEX"` to make addresses relative to an
238    /// object referenced by debug id or index. This for instance is necessary
239    /// for WASM processing as WASM does not use a unified address space.
240    #[serde(default, skip_serializing_if = "Option::is_none")]
241    pub addr_mode: Option<String>,
242}
243
244/// Represents template debug info.
245#[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq)]
246pub struct TemplateInfo {
247    /// The filename (basename only).
248    #[serde(default, skip_serializing_if = "Option::is_none")]
249    pub filename: Option<String>,
250    /// If known the absolute path.
251    #[serde(default, skip_serializing_if = "Option::is_none")]
252    pub abs_path: Option<String>,
253    /// The line number if known.
254    #[serde(default, skip_serializing_if = "Option::is_none")]
255    pub lineno: Option<u64>,
256    /// The column number if known.
257    #[serde(default, skip_serializing_if = "Option::is_none")]
258    pub colno: Option<u64>,
259    /// The sources of the lines leading up to the current line.
260    #[serde(default, skip_serializing_if = "Vec::is_empty")]
261    pub pre_context: Vec<String>,
262    /// The current line as source.
263    #[serde(default, skip_serializing_if = "Option::is_none")]
264    pub context_line: Option<String>,
265    /// The sources of the lines after the current line.
266    #[serde(default, skip_serializing_if = "Vec::is_empty")]
267    pub post_context: Vec<String>,
268}
269
270/// Represents a stacktrace.
271#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq)]
272pub struct Stacktrace {
273    /// The list of frames in the stacktrace.
274    #[serde(default)]
275    pub frames: Vec<Frame>,
276    /// Optionally a segment of frames removed (`start`, `end`).
277    #[serde(default, skip_serializing_if = "Option::is_none")]
278    pub frames_omitted: Option<(u64, u64)>,
279    /// Optional register values of the thread.
280    #[serde(default, skip_serializing_if = "Map::is_empty")]
281    pub registers: Map<String, RegVal>,
282}
283
284impl Stacktrace {
285    /// Optionally creates a stacktrace from a list of stack frames.
286    pub fn from_frames_reversed(mut frames: Vec<Frame>) -> Option<Stacktrace> {
287        if frames.is_empty() {
288            None
289        } else {
290            frames.reverse();
291            Some(Stacktrace {
292                frames,
293                ..Default::default()
294            })
295        }
296    }
297}
298
299/// Represents a thread id.
300#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]
301#[serde(untagged)]
302pub enum ThreadId {
303    /// Integer representation for the thread id
304    Int(u64),
305    /// String representation for the thread id
306    String(String),
307}
308
309impl Default for ThreadId {
310    fn default() -> ThreadId {
311        ThreadId::Int(0)
312    }
313}
314
315impl<'a> From<&'a str> for ThreadId {
316    fn from(id: &'a str) -> ThreadId {
317        ThreadId::String(id.to_string())
318    }
319}
320
321impl From<String> for ThreadId {
322    fn from(id: String) -> ThreadId {
323        ThreadId::String(id)
324    }
325}
326
327impl From<i64> for ThreadId {
328    fn from(id: i64) -> ThreadId {
329        ThreadId::Int(id as u64)
330    }
331}
332
333impl From<i32> for ThreadId {
334    fn from(id: i32) -> ThreadId {
335        ThreadId::Int(id as u64)
336    }
337}
338
339impl From<u32> for ThreadId {
340    fn from(id: u32) -> ThreadId {
341        ThreadId::Int(id as u64)
342    }
343}
344
345impl From<u16> for ThreadId {
346    fn from(id: u16) -> ThreadId {
347        ThreadId::Int(id as u64)
348    }
349}
350
351impl fmt::Display for ThreadId {
352    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
353        match *self {
354            ThreadId::Int(i) => write!(f, "{i}"),
355            ThreadId::String(ref s) => write!(f, "{s}"),
356        }
357    }
358}
359
360/// Represents an address.
361#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Hash)]
362pub struct Addr(pub u64);
363
364impl Addr {
365    /// Returns `true` if this address is the null pointer.
366    pub fn is_null(&self) -> bool {
367        self.0 == 0
368    }
369}
370
371impl_hex_serde!(Addr, u64);
372
373impl From<u64> for Addr {
374    fn from(addr: u64) -> Addr {
375        Addr(addr)
376    }
377}
378
379impl From<i32> for Addr {
380    fn from(addr: i32) -> Addr {
381        Addr(addr as u64)
382    }
383}
384
385impl From<u32> for Addr {
386    fn from(addr: u32) -> Addr {
387        Addr(addr as u64)
388    }
389}
390
391impl From<usize> for Addr {
392    fn from(addr: usize) -> Addr {
393        Addr(addr as u64)
394    }
395}
396
397impl<T> From<*const T> for Addr {
398    fn from(addr: *const T) -> Addr {
399        Addr(addr as u64)
400    }
401}
402
403impl<T> From<*mut T> for Addr {
404    fn from(addr: *mut T) -> Addr {
405        Addr(addr as u64)
406    }
407}
408
409impl From<Addr> for u64 {
410    fn from(addr: Addr) -> Self {
411        addr.0
412    }
413}
414
415fn is_false(value: &bool) -> bool {
416    !*value
417}
418
419/// Represents a register value.
420#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Hash)]
421pub struct RegVal(pub u64);
422
423impl_hex_serde!(RegVal, u64);
424
425impl From<u64> for RegVal {
426    fn from(addr: u64) -> RegVal {
427        RegVal(addr)
428    }
429}
430
431impl From<i32> for RegVal {
432    fn from(addr: i32) -> RegVal {
433        RegVal(addr as u64)
434    }
435}
436
437impl From<u32> for RegVal {
438    fn from(addr: u32) -> RegVal {
439        RegVal(addr as u64)
440    }
441}
442
443impl From<usize> for RegVal {
444    fn from(addr: usize) -> RegVal {
445        RegVal(addr as u64)
446    }
447}
448
449impl<T> From<*const T> for RegVal {
450    fn from(addr: *const T) -> RegVal {
451        RegVal(addr as u64)
452    }
453}
454
455impl<T> From<*mut T> for RegVal {
456    fn from(addr: *mut T) -> RegVal {
457        RegVal(addr as u64)
458    }
459}
460
461impl From<RegVal> for u64 {
462    fn from(reg: RegVal) -> Self {
463        reg.0
464    }
465}
466
467/// Represents a single thread.
468#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq)]
469pub struct Thread {
470    /// The optional ID of the thread (usually an integer)
471    #[serde(default, skip_serializing_if = "Option::is_none")]
472    pub id: Option<ThreadId>,
473    /// The optional name of the thread.
474    #[serde(default, skip_serializing_if = "Option::is_none")]
475    pub name: Option<String>,
476    /// If the thread suspended or crashed a stacktrace can be
477    /// attached here.
478    #[serde(default, skip_serializing_if = "Option::is_none")]
479    pub stacktrace: Option<Stacktrace>,
480    /// Optional raw stacktrace.
481    #[serde(default, skip_serializing_if = "Option::is_none")]
482    pub raw_stacktrace: Option<Stacktrace>,
483    /// True if this is the crashed thread.
484    #[serde(default, skip_serializing_if = "is_false")]
485    pub crashed: bool,
486    /// Indicates that the thread was not suspended when the
487    /// event was created.
488    #[serde(default, skip_serializing_if = "is_false")]
489    pub current: bool,
490}
491
492/// POSIX signal with optional extended data.
493#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq, Eq)]
494pub struct CError {
495    /// The error code as specified by ISO C99, POSIX.1-2001 or POSIX.1-2008.
496    pub number: i32,
497    /// Optional name of the errno constant.
498    #[serde(default, skip_serializing_if = "Option::is_none")]
499    pub name: Option<String>,
500}
501
502impl From<i32> for CError {
503    fn from(number: i32) -> CError {
504        CError { number, name: None }
505    }
506}
507
508impl From<CError> for i32 {
509    fn from(err: CError) -> Self {
510        err.number
511    }
512}
513
514/// Mach exception information.
515#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq, Eq)]
516pub struct MachException {
517    /// The mach exception type.
518    pub exception: i32,
519    /// The mach exception code.
520    pub code: u64,
521    /// The mach exception subcode.
522    pub subcode: u64,
523    /// Optional name of the mach exception.
524    #[serde(default, skip_serializing_if = "Option::is_none")]
525    pub name: Option<String>,
526}
527
528/// POSIX signal with optional extended data.
529#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq, Eq)]
530pub struct PosixSignal {
531    /// The POSIX signal number.
532    pub number: i32,
533    /// An optional signal code present on Apple systems.
534    #[serde(default, skip_serializing_if = "Option::is_none")]
535    pub code: Option<i32>,
536    /// Optional name of the errno constant.
537    #[serde(default, skip_serializing_if = "Option::is_none")]
538    pub name: Option<String>,
539    /// Optional name of the errno constant.
540    #[serde(default, skip_serializing_if = "Option::is_none")]
541    pub code_name: Option<String>,
542}
543
544impl From<i32> for PosixSignal {
545    fn from(number: i32) -> PosixSignal {
546        PosixSignal {
547            number,
548            code: None,
549            name: None,
550            code_name: None,
551        }
552    }
553}
554
555impl From<(i32, i32)> for PosixSignal {
556    fn from(tuple: (i32, i32)) -> PosixSignal {
557        let (number, code) = tuple;
558        PosixSignal {
559            number,
560            code: Some(code),
561            name: None,
562            code_name: None,
563        }
564    }
565}
566
567impl From<PosixSignal> for i32 {
568    fn from(sig: PosixSignal) -> Self {
569        sig.number
570    }
571}
572
573/// Operating system or runtime meta information to an exception mechanism.
574#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq)]
575pub struct MechanismMeta {
576    /// Optional ISO C standard error code.
577    #[serde(default, skip_serializing_if = "Option::is_none")]
578    pub errno: Option<CError>,
579    /// Optional POSIX signal number.
580    #[serde(default, skip_serializing_if = "Option::is_none")]
581    pub signal: Option<PosixSignal>,
582    /// Optional mach exception information.
583    #[serde(default, skip_serializing_if = "Option::is_none")]
584    pub mach_exception: Option<MachException>,
585}
586
587impl MechanismMeta {
588    fn is_empty(&self) -> bool {
589        self.errno.is_none() && self.signal.is_none() && self.mach_exception.is_none()
590    }
591}
592
593/// Represents a single exception.
594#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq)]
595pub struct Mechanism {
596    /// The mechanism type identifier.
597    #[serde(rename = "type")]
598    pub ty: String,
599    /// Human readable detail description.
600    #[serde(default, skip_serializing_if = "Option::is_none")]
601    pub description: Option<String>,
602    /// An optional link to online resources describing this error.
603    #[serde(default, skip_serializing_if = "Option::is_none")]
604    pub help_link: Option<Url>,
605    /// An optional flag indicating whether this exception was handled.
606    #[serde(default, skip_serializing_if = "Option::is_none")]
607    pub handled: Option<bool>,
608    /// An optional flag indicating a synthetic exception.
609    #[serde(default, skip_serializing_if = "Option::is_none")]
610    pub synthetic: Option<bool>,
611    /// Additional attributes depending on the mechanism type.
612    #[serde(default, skip_serializing_if = "Map::is_empty")]
613    pub data: Map<String, Value>,
614    /// Operating system or runtime meta information.
615    #[serde(default, skip_serializing_if = "MechanismMeta::is_empty")]
616    pub meta: MechanismMeta,
617}
618
619/// Represents a single exception.
620#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq)]
621pub struct Exception {
622    /// The type of the exception.
623    #[serde(rename = "type")]
624    pub ty: String,
625    /// The optional value of the exception.
626    #[serde(skip_serializing_if = "Option::is_none")]
627    pub value: Option<String>,
628    /// An optional module for this exception.
629    #[serde(default, skip_serializing_if = "Option::is_none")]
630    pub module: Option<String>,
631    /// Optionally the stacktrace.
632    #[serde(default, skip_serializing_if = "Option::is_none")]
633    pub stacktrace: Option<Stacktrace>,
634    /// An optional raw stacktrace.
635    #[serde(default, skip_serializing_if = "Option::is_none")]
636    pub raw_stacktrace: Option<Stacktrace>,
637    /// Optional identifier referring to a thread.
638    #[serde(default, skip_serializing_if = "Option::is_none")]
639    pub thread_id: Option<ThreadId>,
640    /// The mechanism of the exception including OS specific exception values.
641    #[serde(default, skip_serializing_if = "Option::is_none")]
642    pub mechanism: Option<Mechanism>,
643}
644
645/// An error used when parsing `Level`.
646#[derive(Debug, Error)]
647#[error("invalid level")]
648pub struct ParseLevelError;
649
650/// Represents the level of severity of an event or breadcrumb.
651#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
652pub enum Level {
653    /// Indicates very spammy debug information.
654    Debug,
655    /// Informational messages.
656    #[default]
657    Info,
658    /// A warning.
659    Warning,
660    /// An error.
661    Error,
662    /// Similar to error but indicates a critical event that usually causes a shutdown.
663    Fatal,
664}
665
666impl str::FromStr for Level {
667    type Err = ParseLevelError;
668
669    fn from_str(string: &str) -> Result<Level, Self::Err> {
670        Ok(match string {
671            "debug" => Level::Debug,
672            "info" | "log" => Level::Info,
673            "warning" => Level::Warning,
674            "error" => Level::Error,
675            "fatal" => Level::Fatal,
676            _ => return Err(ParseLevelError),
677        })
678    }
679}
680
681impl fmt::Display for Level {
682    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
683        match *self {
684            Level::Debug => write!(f, "debug"),
685            Level::Info => write!(f, "info"),
686            Level::Warning => write!(f, "warning"),
687            Level::Error => write!(f, "error"),
688            Level::Fatal => write!(f, "fatal"),
689        }
690    }
691}
692
693impl Level {
694    /// A quick way to check if the level is `debug`.
695    pub fn is_debug(&self) -> bool {
696        *self == Level::Debug
697    }
698
699    /// A quick way to check if the level is `info`.
700    pub fn is_info(&self) -> bool {
701        *self == Level::Info
702    }
703
704    /// A quick way to check if the level is `warning`.
705    pub fn is_warning(&self) -> bool {
706        *self == Level::Warning
707    }
708
709    /// A quick way to check if the level is `error`.
710    pub fn is_error(&self) -> bool {
711        *self == Level::Error
712    }
713
714    /// A quick way to check if the level is `fatal`.
715    pub fn is_fatal(&self) -> bool {
716        *self == Level::Fatal
717    }
718}
719
720impl_str_serde!(Level);
721
722mod breadcrumb {
723    use super::*;
724
725    pub fn default_type() -> String {
726        "default".to_string()
727    }
728
729    pub fn is_default_type(ty: &str) -> bool {
730        ty == "default"
731    }
732
733    pub fn default_level() -> Level {
734        Level::Info
735    }
736}
737
738/// Represents a single breadcrumb.
739#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
740pub struct Breadcrumb {
741    /// The timestamp of the breadcrumb.  This is required.
742    #[serde(default = "SystemTime::now", with = "ts_seconds_float")]
743    pub timestamp: SystemTime,
744    /// The type of the breadcrumb.
745    #[serde(
746        rename = "type",
747        default = "breadcrumb::default_type",
748        skip_serializing_if = "breadcrumb::is_default_type"
749    )]
750    pub ty: String,
751    /// The optional category of the breadcrumb.
752    #[serde(default, skip_serializing_if = "Option::is_none")]
753    pub category: Option<String>,
754    /// The non optional level of the breadcrumb.  It
755    /// defaults to info.
756    #[serde(
757        default = "breadcrumb::default_level",
758        skip_serializing_if = "Level::is_info"
759    )]
760    pub level: Level,
761    /// An optional human readbale message for the breadcrumb.
762    #[serde(default, skip_serializing_if = "Option::is_none")]
763    pub message: Option<String>,
764    /// Arbitrary breadcrumb data that should be send along.
765    #[serde(default, skip_serializing_if = "Map::is_empty")]
766    pub data: Map<String, Value>,
767}
768
769impl Default for Breadcrumb {
770    fn default() -> Breadcrumb {
771        Breadcrumb {
772            timestamp: SystemTime::now(),
773            ty: breadcrumb::default_type(),
774            category: Default::default(),
775            level: breadcrumb::default_level(),
776            message: Default::default(),
777            data: Default::default(),
778        }
779    }
780}
781
782/// An IP address, either IPv4, IPv6 or Auto.
783#[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Hash, Default)]
784pub enum IpAddress {
785    /// The IP address needs to be inferred from the user's context.
786    #[default]
787    Auto,
788    /// The exact given IP address (v4 or v6).
789    Exact(IpAddr),
790}
791
792impl PartialEq<IpAddr> for IpAddress {
793    fn eq(&self, other: &IpAddr) -> bool {
794        match *self {
795            IpAddress::Auto => false,
796            IpAddress::Exact(ref addr) => addr == other,
797        }
798    }
799}
800
801impl cmp::PartialOrd<IpAddr> for IpAddress {
802    fn partial_cmp(&self, other: &IpAddr) -> Option<cmp::Ordering> {
803        match *self {
804            IpAddress::Auto => None,
805            IpAddress::Exact(ref addr) => addr.partial_cmp(other),
806        }
807    }
808}
809
810impl fmt::Display for IpAddress {
811    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
812        match *self {
813            IpAddress::Auto => write!(f, "{{{{auto}}}}"),
814            IpAddress::Exact(ref addr) => write!(f, "{addr}"),
815        }
816    }
817}
818
819impl From<IpAddr> for IpAddress {
820    fn from(addr: IpAddr) -> IpAddress {
821        IpAddress::Exact(addr)
822    }
823}
824
825impl str::FromStr for IpAddress {
826    type Err = AddrParseError;
827
828    fn from_str(string: &str) -> Result<IpAddress, AddrParseError> {
829        match string {
830            "{{auto}}" => Ok(IpAddress::Auto),
831            other => other.parse().map(IpAddress::Exact),
832        }
833    }
834}
835
836impl_str_serde!(IpAddress);
837
838/// Represents user info.
839#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq)]
840pub struct User {
841    /// The ID of the user.
842    #[serde(default, skip_serializing_if = "Option::is_none")]
843    pub id: Option<String>,
844    /// The email address of the user.
845    #[serde(default, skip_serializing_if = "Option::is_none")]
846    pub email: Option<String>,
847    /// The remote ip address of the user.
848    #[serde(default, skip_serializing_if = "Option::is_none")]
849    pub ip_address: Option<IpAddress>,
850    /// A human readable username of the user.
851    #[serde(default, skip_serializing_if = "Option::is_none")]
852    pub username: Option<String>,
853    /// Additional arbitrary fields for forwards compatibility.
854    #[serde(flatten)]
855    pub other: Map<String, Value>,
856}
857
858/// Represents http request data.
859#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq)]
860pub struct Request {
861    /// The current URL of the request.
862    #[serde(default, skip_serializing_if = "Option::is_none")]
863    pub url: Option<Url>,
864    /// The HTTP request method.
865    #[serde(default, skip_serializing_if = "Option::is_none")]
866    pub method: Option<String>,
867    /// Optionally some associated request data (human readable)
868    // XXX: this makes absolutely no sense because of unicode
869    #[serde(default, skip_serializing_if = "Option::is_none")]
870    pub data: Option<String>,
871    /// Optionally the encoded query string.
872    #[serde(default, skip_serializing_if = "Option::is_none")]
873    pub query_string: Option<String>,
874    /// An encoded cookie string if available.
875    #[serde(default, skip_serializing_if = "Option::is_none")]
876    pub cookies: Option<String>,
877    /// HTTP request headers.
878    #[serde(default, skip_serializing_if = "Map::is_empty")]
879    pub headers: Map<String, String>,
880    /// Optionally a CGI/WSGI etc. environment dictionary.
881    #[serde(default, skip_serializing_if = "Map::is_empty")]
882    pub env: Map<String, String>,
883}
884
885/// Holds information about the system SDK.
886///
887/// This is relevant for iOS and other platforms that have a system
888/// SDK.  Not to be confused with the client SDK.
889#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
890pub struct SystemSdkInfo {
891    /// The internal name of the SDK
892    pub sdk_name: String,
893    /// the major version of the SDK as integer or 0
894    pub version_major: u32,
895    /// the minor version of the SDK as integer or 0
896    pub version_minor: u32,
897    /// the patch version of the SDK as integer or 0
898    pub version_patchlevel: u32,
899}
900
901/// Represents a debug image.
902#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
903#[serde(rename_all = "snake_case", tag = "type")]
904pub enum DebugImage {
905    /// Apple debug images (machos).  This is currently also used for
906    /// non apple platforms with similar debug setups.
907    Apple(AppleDebugImage),
908    /// Symbolic (new style) debug infos.
909    Symbolic(SymbolicDebugImage),
910    /// A reference to a proguard debug file.
911    Proguard(ProguardDebugImage),
912    /// Image used for WebAssembly. Their structure is identical to other native
913    /// images.
914    Wasm(WasmDebugImage),
915}
916
917impl DebugImage {
918    /// Returns the name of the type on sentry.
919    pub fn type_name(&self) -> &str {
920        match *self {
921            DebugImage::Apple(..) => "apple",
922            DebugImage::Symbolic(..) => "symbolic",
923            DebugImage::Proguard(..) => "proguard",
924            DebugImage::Wasm(..) => "wasm",
925        }
926    }
927}
928
929macro_rules! into_debug_image {
930    ($kind:ident, $ty:ty) => {
931        impl From<$ty> for DebugImage {
932            fn from(data: $ty) -> DebugImage {
933                DebugImage::$kind(data)
934            }
935        }
936    };
937}
938
939/// Represents an apple debug image in the debug meta.
940#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
941pub struct AppleDebugImage {
942    /// The name of the debug image (usually filename)
943    pub name: String,
944    /// The optional CPU architecture of the debug image.
945    pub arch: Option<String>,
946    /// Alternatively a macho cpu type.
947    pub cpu_type: Option<u32>,
948    /// Alternatively a macho cpu subtype.
949    pub cpu_subtype: Option<u32>,
950    /// The starting address of the image.
951    pub image_addr: Addr,
952    /// The size of the image in bytes.
953    pub image_size: u64,
954    /// The address where the image is loaded at runtime.
955    #[serde(default, skip_serializing_if = "Addr::is_null")]
956    pub image_vmaddr: Addr,
957    /// The unique UUID of the image.
958    pub uuid: Uuid,
959}
960
961/// Represents a symbolic debug image.
962#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
963pub struct SymbolicDebugImage {
964    /// Path and name of the image file (required).
965    ///
966    /// The absolute path to the dynamic library or executable. This helps to locate the file if it is missing on Sentry.
967    /// This is also called `code_file`.
968    pub name: String,
969    /// The optional CPU architecture of the debug image.
970    pub arch: Option<String>,
971    /// Starting memory address of the image (required).
972    ///
973    /// Memory address, at which the image is mounted in the virtual address space of the process.
974    pub image_addr: Addr,
975    /// Size of the image in bytes (required).
976    ///
977    /// The size of the image in virtual memory.
978    pub image_size: u64,
979    /// Loading address in virtual memory.
980    ///
981    /// Preferred load address of the image in virtual memory, as declared in the headers of the
982    /// image. When loading an image, the operating system may still choose to place it at a
983    /// different address.
984    ///
985    /// Symbols and addresses in the native image are always relative to the start of the image and do not consider the preferred load address. It is merely a hint to the loader.
986    #[serde(default, skip_serializing_if = "Addr::is_null")]
987    pub image_vmaddr: Addr,
988    /// Unique debug identifier of the image.
989    ///
990    /// This is also called `debug_id`.
991    pub id: DebugId,
992
993    /// Optional identifier of the code file.
994    #[serde(default, skip_serializing_if = "Option::is_none")]
995    pub code_id: Option<CodeId>,
996    /// Path and name of the debug companion file.
997    #[serde(default, skip_serializing_if = "Option::is_none")]
998    pub debug_file: Option<String>,
999}
1000
1001/// Represents a proguard mapping file reference.
1002#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
1003pub struct ProguardDebugImage {
1004    /// The UUID of the associated proguard file.
1005    pub uuid: Uuid,
1006}
1007
1008/// Represents a WebAssembly debug image.
1009#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
1010pub struct WasmDebugImage {
1011    /// The name of the debug image (usually filename)
1012    pub name: String,
1013    /// Identifier of the dynamic library or executable.
1014    pub debug_id: Uuid,
1015    /// Name or absolute URL to the WASM file containing debug information for
1016    /// this image. This value might be required to retrieve debug files from
1017    /// certain symbol servers. This should correspond to the externalized URL
1018    /// pulled from the external_debug_info custom section.
1019    #[serde(default, skip_serializing_if = "Option::is_none")]
1020    pub debug_file: Option<String>,
1021    /// Identifier of the WASM file. It is the value of the build_id custom
1022    /// section formatted as HEX string.
1023    #[serde(default, skip_serializing_if = "Option::is_none")]
1024    pub code_id: Option<String>,
1025    /// The absolute URL to the wasm file. This helps to locate the file if it
1026    /// is missing on Sentry.
1027    pub code_file: String,
1028}
1029
1030into_debug_image!(Apple, AppleDebugImage);
1031into_debug_image!(Symbolic, SymbolicDebugImage);
1032into_debug_image!(Proguard, ProguardDebugImage);
1033into_debug_image!(Wasm, WasmDebugImage);
1034
1035/// Represents debug meta information.
1036#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq)]
1037pub struct DebugMeta {
1038    /// Optional system SDK information.
1039    #[serde(default, skip_serializing_if = "Option::is_none")]
1040    pub sdk_info: Option<SystemSdkInfo>,
1041    /// A list of debug information files.
1042    #[serde(default, skip_serializing_if = "Vec::is_empty")]
1043    pub images: Vec<DebugImage>,
1044}
1045
1046impl DebugMeta {
1047    /// Returns true if the debug meta is empty.
1048    ///
1049    /// This is used by the serializer to entirely skip the section.
1050    pub fn is_empty(&self) -> bool {
1051        self.sdk_info.is_none() && self.images.is_empty()
1052    }
1053}
1054
1055/// Information on the SDK client.
1056#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
1057pub struct ClientSdkInfo {
1058    /// The name of the SDK.
1059    pub name: String,
1060    /// The version of the SDK.
1061    pub version: String,
1062    /// An optional list of integrations that are enabled in this SDK.
1063    #[serde(default, skip_serializing_if = "Vec::is_empty")]
1064    pub integrations: Vec<String>,
1065    /// An optional list of packages that are installed in the SDK's environment.
1066    #[serde(default, skip_serializing_if = "Vec::is_empty")]
1067    pub packages: Vec<ClientSdkPackage>,
1068}
1069
1070/// Represents an installed package relevant to the SDK.
1071#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
1072pub struct ClientSdkPackage {
1073    /// The name of the package installed.
1074    pub name: String,
1075    /// The version of the package.
1076    pub version: String,
1077}
1078
1079/// Typed contextual data.
1080///
1081/// Types like `OsContext` can be directly converted with `.into()`
1082/// to `Context`.
1083#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
1084#[serde(rename_all = "snake_case", tag = "type")]
1085#[non_exhaustive]
1086pub enum Context {
1087    /// Device data.
1088    Device(Box<DeviceContext>),
1089    /// Operating system data.
1090    Os(Box<OsContext>),
1091    /// Runtime data.
1092    Runtime(Box<RuntimeContext>),
1093    /// Application data.
1094    App(Box<AppContext>),
1095    /// Web browser data.
1096    Browser(Box<BrowserContext>),
1097    /// Tracing data.
1098    Trace(Box<TraceContext>),
1099    /// GPU data
1100    Gpu(Box<GpuContext>),
1101    /// Generic other context data.
1102    #[serde(rename = "unknown")]
1103    Other(Map<String, Value>),
1104}
1105
1106impl Context {
1107    /// Returns the name of the type for sentry.
1108    pub fn type_name(&self) -> &str {
1109        match *self {
1110            Context::Device(..) => "device",
1111            Context::Os(..) => "os",
1112            Context::Runtime(..) => "runtime",
1113            Context::App(..) => "app",
1114            Context::Browser(..) => "browser",
1115            Context::Trace(..) => "trace",
1116            Context::Gpu(..) => "gpu",
1117            Context::Other(..) => "unknown",
1118        }
1119    }
1120}
1121
1122/// Optional device screen orientation
1123#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash)]
1124#[serde(rename_all = "lowercase")]
1125pub enum Orientation {
1126    /// Portrait device orientation.
1127    Portrait,
1128    /// Landscape device orientation.
1129    Landscape,
1130}
1131
1132/// Holds device information.
1133#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq)]
1134pub struct DeviceContext {
1135    /// The name of the device.
1136    #[serde(default, skip_serializing_if = "Option::is_none")]
1137    pub name: Option<String>,
1138    /// The family of the device model.
1139    #[serde(default, skip_serializing_if = "Option::is_none")]
1140    pub family: Option<String>,
1141    /// The device model (human readable).
1142    #[serde(default, skip_serializing_if = "Option::is_none")]
1143    pub model: Option<String>,
1144    /// The device model (internal identifier).
1145    #[serde(default, skip_serializing_if = "Option::is_none")]
1146    pub model_id: Option<String>,
1147    /// The native cpu architecture of the device.
1148    #[serde(default, skip_serializing_if = "Option::is_none")]
1149    pub arch: Option<String>,
1150    /// The current battery level (0-100).
1151    #[serde(default, skip_serializing_if = "Option::is_none")]
1152    pub battery_level: Option<f32>,
1153    /// The current screen orientation.
1154    #[serde(default, skip_serializing_if = "Option::is_none")]
1155    pub orientation: Option<Orientation>,
1156    /// Simulator/prod indicator.
1157    #[serde(default, skip_serializing_if = "Option::is_none")]
1158    pub simulator: Option<bool>,
1159    /// Total memory available in byts.
1160    #[serde(default, skip_serializing_if = "Option::is_none")]
1161    pub memory_size: Option<u64>,
1162    /// How much memory is still available in bytes.
1163    #[serde(default, skip_serializing_if = "Option::is_none")]
1164    pub free_memory: Option<u64>,
1165    /// How much memory is usable for the app in bytes.
1166    #[serde(default, skip_serializing_if = "Option::is_none")]
1167    pub usable_memory: Option<u64>,
1168    /// Total storage size of the device in bytes.
1169    #[serde(default, skip_serializing_if = "Option::is_none")]
1170    pub storage_size: Option<u64>,
1171    /// How much storage is free in bytes.
1172    #[serde(default, skip_serializing_if = "Option::is_none")]
1173    pub free_storage: Option<u64>,
1174    /// Total size of the attached external storage in bytes (eg: android SDK card).
1175    #[serde(default, skip_serializing_if = "Option::is_none")]
1176    pub external_storage_size: Option<u64>,
1177    /// Free size of the attached external storage in bytes (eg: android SDK card).
1178    #[serde(default, skip_serializing_if = "Option::is_none")]
1179    pub external_free_storage: Option<u64>,
1180    /// Optionally an indicator when the device was booted.
1181    #[serde(
1182        default,
1183        skip_serializing_if = "Option::is_none",
1184        with = "ts_rfc3339_opt"
1185    )]
1186    pub boot_time: Option<SystemTime>,
1187    /// The timezone of the device.
1188    #[serde(default, skip_serializing_if = "Option::is_none")]
1189    pub timezone: Option<String>,
1190    /// Additional arbitrary fields for forwards compatibility.
1191    #[serde(flatten)]
1192    pub other: Map<String, Value>,
1193}
1194
1195/// Holds operating system information.
1196#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq)]
1197pub struct OsContext {
1198    /// The name of the operating system.
1199    #[serde(default, skip_serializing_if = "Option::is_none")]
1200    pub name: Option<String>,
1201    /// The version of the operating system.
1202    #[serde(default, skip_serializing_if = "Option::is_none")]
1203    pub version: Option<String>,
1204    /// The internal build number of the operating system.
1205    #[serde(default, skip_serializing_if = "Option::is_none")]
1206    pub build: Option<String>,
1207    /// The current kernel version.
1208    #[serde(default, skip_serializing_if = "Option::is_none")]
1209    pub kernel_version: Option<String>,
1210    /// An indicator if the os is rooted (mobile mostly).
1211    #[serde(default, skip_serializing_if = "Option::is_none")]
1212    pub rooted: Option<bool>,
1213    /// Additional arbitrary fields for forwards compatibility.
1214    #[serde(flatten)]
1215    pub other: Map<String, Value>,
1216}
1217
1218/// Holds information about the runtime.
1219#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq)]
1220pub struct RuntimeContext {
1221    /// The name of the runtime (for instance JVM).
1222    #[serde(default, skip_serializing_if = "Option::is_none")]
1223    pub name: Option<String>,
1224    /// The version of the runtime.
1225    #[serde(default, skip_serializing_if = "Option::is_none")]
1226    pub version: Option<String>,
1227    /// Additional arbitrary fields for forwards compatibility.
1228    #[serde(flatten)]
1229    pub other: Map<String, Value>,
1230}
1231
1232/// Holds app information.
1233#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq)]
1234pub struct AppContext {
1235    /// Optional start time of the app.
1236    #[serde(
1237        default,
1238        skip_serializing_if = "Option::is_none",
1239        with = "ts_rfc3339_opt"
1240    )]
1241    pub app_start_time: Option<SystemTime>,
1242    /// Optional device app hash (app specific device ID)
1243    #[serde(default, skip_serializing_if = "Option::is_none")]
1244    pub device_app_hash: Option<String>,
1245    /// Optional build identicator.
1246    #[serde(default, skip_serializing_if = "Option::is_none")]
1247    pub build_type: Option<String>,
1248    /// Optional app identifier (dotted bundle id).
1249    #[serde(default, skip_serializing_if = "Option::is_none")]
1250    pub app_identifier: Option<String>,
1251    /// Application name as it appears on the platform.
1252    #[serde(default, skip_serializing_if = "Option::is_none")]
1253    pub app_name: Option<String>,
1254    /// Application version as it appears on the platform.
1255    #[serde(default, skip_serializing_if = "Option::is_none")]
1256    pub app_version: Option<String>,
1257    /// Internal build ID as it appears on the platform.
1258    #[serde(default, skip_serializing_if = "Option::is_none")]
1259    pub app_build: Option<String>,
1260    /// Additional arbitrary fields for forwards compatibility.
1261    #[serde(flatten)]
1262    pub other: Map<String, Value>,
1263}
1264
1265/// Holds information about the web browser.
1266#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq)]
1267pub struct BrowserContext {
1268    /// The name of the browser (for instance "Chrome").
1269    #[serde(default, skip_serializing_if = "Option::is_none")]
1270    pub name: Option<String>,
1271    /// The version of the browser.
1272    #[serde(default, skip_serializing_if = "Option::is_none")]
1273    pub version: Option<String>,
1274    /// Additional arbitrary fields for forwards compatibility.
1275    #[serde(flatten)]
1276    pub other: Map<String, Value>,
1277}
1278
1279/// GPU context describes the GPU of the device.
1280#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq)]
1281pub struct GpuContext {
1282    /// The name of the graphics device.
1283    pub name: String,
1284    /// The Version of the graphics device.
1285    #[serde(default, skip_serializing_if = "Option::is_none")]
1286    pub version: Option<String>,
1287    /// The version of the graphic device driver.
1288    #[serde(default, skip_serializing_if = "Option::is_none")]
1289    pub driver_version: Option<String>,
1290    /// The PCI identifier of the graphics device.
1291    #[serde(default, skip_serializing_if = "Option::is_none")]
1292    pub id: Option<String>,
1293    /// The PCI vendor identifier of the graphics device.
1294    #[serde(default, skip_serializing_if = "Option::is_none")]
1295    pub vendor_id: Option<String>,
1296    /// The vendor name as reported by the graphics device.
1297    #[serde(default, skip_serializing_if = "Option::is_none")]
1298    pub vendor_name: Option<String>,
1299    /// The total GPU memory available in Megabytes.
1300    #[serde(default, skip_serializing_if = "Option::is_none")]
1301    pub memory_size: Option<u32>,
1302    /// The device low-level API type. Examples: "Apple Metal" or "Direct3D11"
1303    #[serde(default, skip_serializing_if = "Option::is_none")]
1304    pub api_type: Option<String>,
1305    /// Whether the GPU has multi-threaded rendering or not.
1306    #[serde(default, skip_serializing_if = "Option::is_none")]
1307    pub multi_threaded_rendering: Option<bool>,
1308    /// The Non-Power-Of-Two-Support support.
1309    #[serde(default, skip_serializing_if = "Option::is_none")]
1310    pub npot_support: Option<bool>,
1311    /// Largest size of a texture that is supported by the graphics hardware.
1312    #[serde(default, skip_serializing_if = "Option::is_none")]
1313    pub max_texture_size: Option<u32>,
1314    /// Approximate "shader capability" level of the graphics device. For example,
1315    /// `Shader Model 2.0, OpenGL ES 3.0, Metal / OpenGL ES 3.1, 27 (unknown)`.
1316    #[serde(default, skip_serializing_if = "Option::is_none")]
1317    pub graphics_shader_level: Option<String>,
1318    /// Is GPU draw call instancing supported?
1319    #[serde(default, skip_serializing_if = "Option::is_none")]
1320    pub supports_draw_call_instancing: Option<bool>,
1321    /// Is ray tracing available on the device?
1322    #[serde(default, skip_serializing_if = "Option::is_none")]
1323    pub supports_ray_tracing: Option<bool>,
1324    /// Are compute shaders available on the device?
1325    #[serde(default, skip_serializing_if = "Option::is_none")]
1326    pub supports_compute_shaders: Option<bool>,
1327    /// Are geometry shaders available on the device?
1328    #[serde(default, skip_serializing_if = "Option::is_none")]
1329    pub supports_geometry_shaders: Option<bool>,
1330    /// Additional arbitrary fields for forwards compatibility.
1331    #[serde(flatten)]
1332    pub other: Map<String, Value>,
1333}
1334
1335/// Holds the identifier for a Span
1336#[derive(Serialize, Deserialize, Debug, Copy, Clone, Eq, PartialEq, Hash)]
1337#[serde(try_from = "String", into = "String")]
1338pub struct SpanId([u8; 8]);
1339
1340impl Default for SpanId {
1341    fn default() -> Self {
1342        Self(rand::random())
1343    }
1344}
1345
1346impl fmt::Display for SpanId {
1347    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1348        write!(fmt, "{}", hex::encode(self.0))
1349    }
1350}
1351
1352impl From<SpanId> for String {
1353    fn from(span_id: SpanId) -> Self {
1354        span_id.to_string()
1355    }
1356}
1357
1358impl str::FromStr for SpanId {
1359    type Err = hex::FromHexError;
1360
1361    fn from_str(input: &str) -> Result<Self, Self::Err> {
1362        let mut buf = [0; 8];
1363        hex::decode_to_slice(input, &mut buf)?;
1364        Ok(Self(buf))
1365    }
1366}
1367
1368impl TryFrom<String> for SpanId {
1369    type Error = hex::FromHexError;
1370
1371    fn try_from(value: String) -> Result<Self, Self::Error> {
1372        value.parse()
1373    }
1374}
1375
1376/// Holds the identifier for a Trace
1377#[derive(Serialize, Deserialize, Debug, Copy, Clone, Eq, PartialEq, Hash)]
1378#[serde(try_from = "String", into = "String")]
1379pub struct TraceId([u8; 16]);
1380
1381impl Default for TraceId {
1382    fn default() -> Self {
1383        Self(rand::random())
1384    }
1385}
1386
1387impl fmt::Display for TraceId {
1388    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1389        write!(fmt, "{}", hex::encode(self.0))
1390    }
1391}
1392
1393impl From<TraceId> for String {
1394    fn from(trace_id: TraceId) -> Self {
1395        trace_id.to_string()
1396    }
1397}
1398
1399impl str::FromStr for TraceId {
1400    type Err = hex::FromHexError;
1401
1402    fn from_str(input: &str) -> Result<Self, Self::Err> {
1403        let mut buf = [0; 16];
1404        hex::decode_to_slice(input, &mut buf)?;
1405        Ok(Self(buf))
1406    }
1407}
1408
1409impl TryFrom<String> for TraceId {
1410    type Error = hex::FromHexError;
1411
1412    fn try_from(value: String) -> Result<Self, Self::Error> {
1413        value.parse()
1414    }
1415}
1416
1417/// Holds information about a tracing event.
1418#[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq)]
1419pub struct TraceContext {
1420    /// The ID of the trace event
1421    #[serde(default)]
1422    pub span_id: SpanId,
1423    /// Determines which trace the transaction belongs to.
1424    #[serde(default)]
1425    pub trace_id: TraceId,
1426    /// Determines the parent of this transaction if any.
1427    #[serde(default, skip_serializing_if = "Option::is_none")]
1428    pub parent_span_id: Option<SpanId>,
1429    /// Short code identifying the type of operation the transaction is measuring.
1430    #[serde(default, skip_serializing_if = "Option::is_none")]
1431    pub op: Option<String>,
1432    /// Human readable detail description.
1433    #[serde(default, skip_serializing_if = "Option::is_none")]
1434    pub description: Option<String>,
1435    /// Describes the status of the span (e.g. `ok`, `cancelled`, etc.)
1436    #[serde(default, skip_serializing_if = "Option::is_none")]
1437    pub status: Option<SpanStatus>,
1438    /// Optional data attributes to be associated with the transaction.
1439    #[serde(default, skip_serializing_if = "Map::is_empty")]
1440    pub data: Map<String, Value>,
1441}
1442
1443macro_rules! into_context {
1444    ($kind:ident, $ty:ty) => {
1445        impl From<$ty> for Context {
1446            fn from(data: $ty) -> Self {
1447                Context::$kind(Box::new(data))
1448            }
1449        }
1450    };
1451}
1452
1453into_context!(App, AppContext);
1454into_context!(Device, DeviceContext);
1455into_context!(Os, OsContext);
1456into_context!(Runtime, RuntimeContext);
1457into_context!(Browser, BrowserContext);
1458into_context!(Trace, TraceContext);
1459into_context!(Gpu, GpuContext);
1460
1461const INFERABLE_CONTEXTS: &[&str] = &["device", "os", "runtime", "app", "browser", "trace", "gpu"];
1462
1463struct ContextsVisitor;
1464
1465impl<'de> de::Visitor<'de> for ContextsVisitor {
1466    type Value = Map<String, Context>;
1467
1468    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1469        formatter.write_str("contexts object")
1470    }
1471
1472    fn visit_map<A>(self, mut access: A) -> Result<Self::Value, A::Error>
1473    where
1474        A: de::MapAccess<'de>,
1475    {
1476        let mut map: Map<String, Context> = Map::new();
1477
1478        while let Some((key, mut value)) = access.next_entry::<String, Value>()? {
1479            let typed_value = value
1480                .as_object_mut()
1481                .map(|ctx| {
1482                    if !ctx.contains_key("type") {
1483                        let type_key = if INFERABLE_CONTEXTS.contains(&key.as_str()) {
1484                            key.clone().into()
1485                        } else {
1486                            Value::String("unknown".into())
1487                        };
1488                        ctx.insert(String::from("type"), type_key);
1489                    }
1490                    ctx.to_owned()
1491                })
1492                .ok_or_else(|| de::Error::custom("expected valid `context` object"))?;
1493
1494            match serde_json::from_value(serde_json::to_value(typed_value).unwrap()) {
1495                Ok(context) => {
1496                    map.insert(key, context);
1497                }
1498                Err(e) => return Err(de::Error::custom(e.to_string())),
1499            }
1500        }
1501
1502        Ok(map)
1503    }
1504}
1505
1506fn deserialize_contexts<'de, D>(deserializer: D) -> Result<Map<String, Context>, D::Error>
1507where
1508    D: Deserializer<'de>,
1509{
1510    deserializer.deserialize_map(ContextsVisitor {})
1511}
1512
1513mod event {
1514    use super::*;
1515
1516    pub fn default_id() -> Uuid {
1517        crate::random_uuid()
1518    }
1519
1520    pub fn serialize_id<S: Serializer>(uuid: &Uuid, serializer: S) -> Result<S::Ok, S::Error> {
1521        serializer.serialize_some(&uuid.as_simple().to_string())
1522    }
1523
1524    pub fn default_level() -> Level {
1525        Level::Error
1526    }
1527
1528    pub fn default_platform() -> Cow<'static, str> {
1529        Cow::Borrowed("other")
1530    }
1531
1532    pub fn is_default_platform(value: &str) -> bool {
1533        value == "other"
1534    }
1535
1536    static DEFAULT_FINGERPRINT: &[Cow<'static, str>] = &[Cow::Borrowed("{{ default }}")];
1537
1538    pub fn default_fingerprint<'a>() -> Cow<'a, [Cow<'a, str>]> {
1539        Cow::Borrowed(DEFAULT_FINGERPRINT)
1540    }
1541
1542    pub fn is_default_fingerprint(fp: &[Cow<'_, str>]) -> bool {
1543        fp.len() == 1 && ((fp)[0] == "{{ default }}" || (fp)[0] == "{{default}}")
1544    }
1545}
1546
1547/// Represents a full event for Sentry.
1548#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
1549pub struct Event<'a> {
1550    /// The ID of the event
1551    #[serde(default = "event::default_id", serialize_with = "event::serialize_id")]
1552    pub event_id: Uuid,
1553    /// The level of the event (defaults to error)
1554    #[serde(
1555        default = "event::default_level",
1556        skip_serializing_if = "Level::is_error"
1557    )]
1558    pub level: Level,
1559    /// An optional fingerprint configuration to override the default.
1560    #[serde(
1561        default = "event::default_fingerprint",
1562        skip_serializing_if = "event::is_default_fingerprint"
1563    )]
1564    pub fingerprint: Cow<'a, [Cow<'a, str>]>,
1565    /// The culprit of the event.
1566    #[serde(default, skip_serializing_if = "Option::is_none")]
1567    pub culprit: Option<String>,
1568    /// The transaction name of the event.
1569    #[serde(default, skip_serializing_if = "Option::is_none")]
1570    pub transaction: Option<String>,
1571    /// A message to be sent with the event.
1572    #[serde(default, skip_serializing_if = "Option::is_none")]
1573    pub message: Option<String>,
1574    /// Optionally a log entry that can be used instead of the message for
1575    /// more complex cases.
1576    #[serde(default, skip_serializing_if = "Option::is_none")]
1577    pub logentry: Option<LogEntry>,
1578    /// Optionally the name of the logger that created this event.
1579    #[serde(default, skip_serializing_if = "Option::is_none")]
1580    pub logger: Option<String>,
1581    /// Optionally a name to version mapping of installed modules.
1582    #[serde(default, skip_serializing_if = "Map::is_empty")]
1583    pub modules: Map<String, String>,
1584    /// A platform identifier for this event.
1585    #[serde(
1586        default = "event::default_platform",
1587        skip_serializing_if = "event::is_default_platform"
1588    )]
1589    pub platform: Cow<'a, str>,
1590    /// The timestamp of when the event was created.
1591    ///
1592    /// This can be set to `None` in which case the server will set a timestamp.
1593    #[serde(default = "SystemTime::now", with = "ts_seconds_float")]
1594    pub timestamp: SystemTime,
1595    /// Optionally the server (or device) name of this event.
1596    #[serde(default, skip_serializing_if = "Option::is_none")]
1597    pub server_name: Option<Cow<'a, str>>,
1598    /// A release identifier.
1599    #[serde(default, skip_serializing_if = "Option::is_none")]
1600    pub release: Option<Cow<'a, str>>,
1601    /// An optional distribution identifier.
1602    #[serde(default, skip_serializing_if = "Option::is_none")]
1603    pub dist: Option<Cow<'a, str>>,
1604    /// An optional environment identifier.
1605    #[serde(default, skip_serializing_if = "Option::is_none")]
1606    pub environment: Option<Cow<'a, str>>,
1607    /// Optionally user data to be sent along.
1608    #[serde(default, skip_serializing_if = "Option::is_none")]
1609    pub user: Option<User>,
1610    /// Optionally HTTP request data to be sent along.
1611    #[serde(default, skip_serializing_if = "Option::is_none")]
1612    pub request: Option<Request>,
1613    /// Optional contexts.
1614    #[serde(
1615        default,
1616        skip_serializing_if = "Map::is_empty",
1617        deserialize_with = "deserialize_contexts"
1618    )]
1619    pub contexts: Map<String, Context>,
1620    /// List of breadcrumbs to send along.
1621    #[serde(default, skip_serializing_if = "Values::is_empty")]
1622    pub breadcrumbs: Values<Breadcrumb>,
1623    /// Exceptions to be attached (one or multiple if chained).
1624    #[serde(default, skip_serializing_if = "Values::is_empty")]
1625    pub exception: Values<Exception>,
1626    /// A single stacktrace (deprecated)
1627    #[serde(default, skip_serializing_if = "Option::is_none")]
1628    pub stacktrace: Option<Stacktrace>,
1629    /// Simplified template error location info
1630    #[serde(default, skip_serializing_if = "Option::is_none")]
1631    pub template: Option<TemplateInfo>,
1632    /// A list of threads.
1633    #[serde(default, skip_serializing_if = "Values::is_empty")]
1634    pub threads: Values<Thread>,
1635    /// Optional tags to be attached to the event.
1636    #[serde(default, skip_serializing_if = "Map::is_empty")]
1637    pub tags: Map<String, String>,
1638    /// Optional extra information to be sent with the event.
1639    #[serde(default, skip_serializing_if = "Map::is_empty")]
1640    pub extra: Map<String, Value>,
1641    /// Debug meta information.
1642    #[serde(default, skip_serializing_if = "DebugMeta::is_empty")]
1643    pub debug_meta: Cow<'a, DebugMeta>,
1644    /// SDK metadata
1645    #[serde(default, skip_serializing_if = "Option::is_none")]
1646    pub sdk: Option<Cow<'a, ClientSdkInfo>>,
1647}
1648
1649impl Default for Event<'_> {
1650    fn default() -> Self {
1651        Event {
1652            event_id: event::default_id(),
1653            level: event::default_level(),
1654            fingerprint: event::default_fingerprint(),
1655            culprit: Default::default(),
1656            transaction: Default::default(),
1657            message: Default::default(),
1658            logentry: Default::default(),
1659            logger: Default::default(),
1660            modules: Default::default(),
1661            platform: event::default_platform(),
1662            timestamp: SystemTime::now(),
1663            server_name: Default::default(),
1664            release: Default::default(),
1665            dist: Default::default(),
1666            environment: Default::default(),
1667            user: Default::default(),
1668            request: Default::default(),
1669            contexts: Default::default(),
1670            breadcrumbs: Default::default(),
1671            exception: Default::default(),
1672            stacktrace: Default::default(),
1673            template: Default::default(),
1674            threads: Default::default(),
1675            tags: Default::default(),
1676            extra: Default::default(),
1677            debug_meta: Default::default(),
1678            sdk: Default::default(),
1679        }
1680    }
1681}
1682
1683impl<'a> Event<'a> {
1684    /// Creates a new event with the current timestamp and random id.
1685    pub fn new() -> Event<'a> {
1686        Default::default()
1687    }
1688
1689    /// Creates a fully owned version of the event.
1690    pub fn into_owned(self) -> Event<'static> {
1691        Event {
1692            event_id: self.event_id,
1693            level: self.level,
1694            fingerprint: Cow::Owned(
1695                self.fingerprint
1696                    .iter()
1697                    .map(|x| Cow::Owned(x.to_string()))
1698                    .collect(),
1699            ),
1700            culprit: self.culprit,
1701            transaction: self.transaction,
1702            message: self.message,
1703            logentry: self.logentry,
1704            logger: self.logger,
1705            modules: self.modules,
1706            platform: Cow::Owned(self.platform.into_owned()),
1707            timestamp: self.timestamp,
1708            server_name: self.server_name.map(|x| Cow::Owned(x.into_owned())),
1709            release: self.release.map(|x| Cow::Owned(x.into_owned())),
1710            dist: self.dist.map(|x| Cow::Owned(x.into_owned())),
1711            environment: self.environment.map(|x| Cow::Owned(x.into_owned())),
1712            user: self.user,
1713            request: self.request,
1714            contexts: self.contexts,
1715            breadcrumbs: self.breadcrumbs,
1716            exception: self.exception,
1717            stacktrace: self.stacktrace,
1718            template: self.template,
1719            threads: self.threads,
1720            tags: self.tags,
1721            extra: self.extra,
1722            debug_meta: Cow::Owned(self.debug_meta.into_owned()),
1723            sdk: self.sdk.map(|x| Cow::Owned(x.into_owned())),
1724        }
1725    }
1726}
1727
1728impl fmt::Display for Event<'_> {
1729    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1730        write!(
1731            f,
1732            "Event(id: {}, ts: {})",
1733            self.event_id,
1734            crate::utils::to_rfc3339(&self.timestamp)
1735        )
1736    }
1737}
1738
1739/// Represents a tracing span.
1740#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
1741pub struct Span {
1742    /// The ID of the span
1743    #[serde(default)]
1744    pub span_id: SpanId,
1745    /// Determines which trace the span belongs to.
1746    #[serde(default)]
1747    pub trace_id: TraceId,
1748    /// Determines the parent of this span, if any.
1749    #[serde(default, skip_serializing_if = "Option::is_none")]
1750    pub parent_span_id: Option<SpanId>,
1751    /// Determines whether this span is generated in the same process as its parent, if any.
1752    #[serde(default, skip_serializing_if = "Option::is_none")]
1753    pub same_process_as_parent: Option<bool>,
1754    /// Short code identifying the type of operation the span is measuring.
1755    #[serde(default, skip_serializing_if = "Option::is_none")]
1756    pub op: Option<String>,
1757    /// Longer description of the span's operation, which uniquely identifies the span
1758    /// but is consistent across instances of the span.
1759    #[serde(default, skip_serializing_if = "Option::is_none")]
1760    pub description: Option<String>,
1761    /// The timestamp at the measuring of the span finished.
1762    #[serde(
1763        default,
1764        skip_serializing_if = "Option::is_none",
1765        with = "ts_rfc3339_opt"
1766    )]
1767    pub timestamp: Option<SystemTime>,
1768    /// The timestamp at the measuring of the span started.
1769    #[serde(default = "SystemTime::now", with = "ts_seconds_float")]
1770    pub start_timestamp: SystemTime,
1771    /// Describes the status of the span (e.g. `ok`, `cancelled`, etc.)
1772    #[serde(default, skip_serializing_if = "Option::is_none")]
1773    pub status: Option<SpanStatus>,
1774    /// Optional tags to be attached to the span.
1775    #[serde(default, skip_serializing_if = "Map::is_empty")]
1776    pub tags: Map<String, String>,
1777    /// Optional extra information to be sent with the span.
1778    #[serde(default, skip_serializing_if = "Map::is_empty")]
1779    pub data: Map<String, Value>,
1780}
1781
1782impl Default for Span {
1783    fn default() -> Self {
1784        Span {
1785            span_id: Default::default(),
1786            trace_id: Default::default(),
1787            timestamp: Default::default(),
1788            tags: Default::default(),
1789            start_timestamp: SystemTime::now(),
1790            description: Default::default(),
1791            status: Default::default(),
1792            parent_span_id: Default::default(),
1793            same_process_as_parent: Default::default(),
1794            op: Default::default(),
1795            data: Default::default(),
1796        }
1797    }
1798}
1799
1800impl Span {
1801    /// Creates a new span with the current timestamp and random id.
1802    pub fn new() -> Span {
1803        Default::default()
1804    }
1805
1806    /// Finalizes the span.
1807    pub fn finish(&mut self) {
1808        self.timestamp = Some(SystemTime::now());
1809    }
1810}
1811
1812impl fmt::Display for Span {
1813    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1814        write!(
1815            f,
1816            "Span(id: {}, ts: {})",
1817            self.span_id,
1818            crate::utils::to_rfc3339(&self.start_timestamp)
1819        )
1820    }
1821}
1822
1823/// An error used when parsing `SpanStatus`.
1824#[derive(Debug, Error)]
1825#[error("invalid status")]
1826pub struct ParseStatusError;
1827
1828/// The status of a Span.
1829#[derive(Serialize, Deserialize, Debug, Copy, Clone, PartialEq, Eq, Hash)]
1830#[non_exhaustive]
1831pub enum SpanStatus {
1832    /// The operation completed successfully.
1833    #[serde(rename = "ok")]
1834    Ok,
1835    /// Deadline expired before operation could complete.
1836    #[serde(rename = "deadline_exceeded")]
1837    DeadlineExceeded,
1838    /// 401 Unauthorized (actually does mean unauthenticated according to RFC 7235)
1839    #[serde(rename = "unauthenticated")]
1840    Unauthenticated,
1841    /// 403 Forbidden
1842    #[serde(rename = "permission_denied")]
1843    PermissionDenied,
1844    /// 404 Not Found. Some requested entity (file or directory) was not found.
1845    #[serde(rename = "not_found")]
1846    NotFound,
1847    /// 429 Too Many Requests
1848    #[serde(rename = "resource_exhausted")]
1849    ResourceExhausted,
1850    /// Client specified an invalid argument. 4xx.
1851    #[serde(rename = "invalid_argument")]
1852    InvalidArgument,
1853    /// 501 Not Implemented
1854    #[serde(rename = "unimplemented")]
1855    Unimplemented,
1856    /// 503 Service Unavailable
1857    #[serde(rename = "unavailable")]
1858    Unavailable,
1859    /// Other/generic 5xx.
1860    #[serde(rename = "internal_error")]
1861    InternalError,
1862    /// Unknown. Any non-standard HTTP status code.
1863    #[serde(rename = "unknown_error")]
1864    UnknownError,
1865    /// The operation was cancelled (typically by the user).
1866    #[serde(rename = "cancelled")]
1867    Cancelled,
1868    /// Already exists (409)
1869    #[serde(rename = "already_exists")]
1870    AlreadyExists,
1871    /// Operation was rejected because the system is not in a state required for the operation's
1872    #[serde(rename = "failed_precondition")]
1873    FailedPrecondition,
1874    /// The operation was aborted, typically due to a concurrency issue.
1875    #[serde(rename = "aborted")]
1876    Aborted,
1877    /// Operation was attempted past the valid range.
1878    #[serde(rename = "out_of_range")]
1879    OutOfRange,
1880    /// Unrecoverable data loss or corruption
1881    #[serde(rename = "data_loss")]
1882    DataLoss,
1883}
1884
1885impl str::FromStr for SpanStatus {
1886    type Err = ParseStatusError;
1887
1888    fn from_str(s: &str) -> Result<SpanStatus, Self::Err> {
1889        Ok(match s {
1890            "ok" => SpanStatus::Ok,
1891            "deadline_exceeded" => SpanStatus::DeadlineExceeded,
1892            "unauthenticated" => SpanStatus::Unauthenticated,
1893            "permission_denied" => SpanStatus::PermissionDenied,
1894            "not_found" => SpanStatus::NotFound,
1895            "resource_exhausted" => SpanStatus::ResourceExhausted,
1896            "invalid_argument" => SpanStatus::InvalidArgument,
1897            "unimplemented" => SpanStatus::Unimplemented,
1898            "unavailable" => SpanStatus::Unavailable,
1899            "internal_error" => SpanStatus::InternalError,
1900            "unknown_error" => SpanStatus::UnknownError,
1901            "cancelled" => SpanStatus::Cancelled,
1902            "already_exists" => SpanStatus::AlreadyExists,
1903            "failed_precondition" => SpanStatus::FailedPrecondition,
1904            "aborted" => SpanStatus::Aborted,
1905            "out_of_range" => SpanStatus::OutOfRange,
1906            "data_loss" => SpanStatus::DataLoss,
1907            _ => return Err(ParseStatusError),
1908        })
1909    }
1910}
1911
1912impl fmt::Display for SpanStatus {
1913    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1914        match self {
1915            SpanStatus::Ok => write!(f, "ok"),
1916            SpanStatus::DeadlineExceeded => write!(f, "deadline_exceeded"),
1917            SpanStatus::Unauthenticated => write!(f, "unauthenticated"),
1918            SpanStatus::PermissionDenied => write!(f, "permission_denied"),
1919            SpanStatus::NotFound => write!(f, "not_found"),
1920            SpanStatus::ResourceExhausted => write!(f, "resource_exhausted"),
1921            SpanStatus::InvalidArgument => write!(f, "invalid_argument"),
1922            SpanStatus::Unimplemented => write!(f, "unimplemented"),
1923            SpanStatus::Unavailable => write!(f, "unavailable"),
1924            SpanStatus::InternalError => write!(f, "internal_error"),
1925            SpanStatus::UnknownError => write!(f, "unknown_error"),
1926            SpanStatus::Cancelled => write!(f, "cancelled"),
1927            SpanStatus::AlreadyExists => write!(f, "already_exists"),
1928            SpanStatus::FailedPrecondition => write!(f, "failed_precondition"),
1929            SpanStatus::Aborted => write!(f, "aborted"),
1930            SpanStatus::OutOfRange => write!(f, "out_of_range"),
1931            SpanStatus::DataLoss => write!(f, "data_loss"),
1932        }
1933    }
1934}
1935
1936/// Represents a tracing transaction.
1937#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
1938pub struct Transaction<'a> {
1939    /// The ID of the event
1940    #[serde(default = "event::default_id", serialize_with = "event::serialize_id")]
1941    pub event_id: Uuid,
1942    /// The transaction name.
1943    #[serde(
1944        rename = "transaction",
1945        default,
1946        skip_serializing_if = "Option::is_none"
1947    )]
1948    pub name: Option<String>,
1949    /// A release identifier.
1950    #[serde(default, skip_serializing_if = "Option::is_none")]
1951    pub release: Option<Cow<'a, str>>,
1952    /// An optional environment identifier.
1953    #[serde(default, skip_serializing_if = "Option::is_none")]
1954    pub environment: Option<Cow<'a, str>>,
1955    /// Optionally user data to be sent along.
1956    #[serde(default, skip_serializing_if = "Option::is_none")]
1957    pub user: Option<User>,
1958    /// Optional tags to be attached to the event.
1959    #[serde(default, skip_serializing_if = "Map::is_empty")]
1960    pub tags: Map<String, String>,
1961    /// Optional extra information to be sent with the event.
1962    #[serde(default, skip_serializing_if = "Map::is_empty")]
1963    pub extra: Map<String, Value>,
1964    /// SDK metadata
1965    #[serde(default, skip_serializing_if = "Option::is_none")]
1966    pub sdk: Option<Cow<'a, ClientSdkInfo>>,
1967    /// A platform identifier for this event.
1968    #[serde(
1969        default = "event::default_platform",
1970        skip_serializing_if = "event::is_default_platform"
1971    )]
1972    pub platform: Cow<'a, str>,
1973    /// The end time of the transaction.
1974    #[serde(
1975        default,
1976        skip_serializing_if = "Option::is_none",
1977        with = "ts_rfc3339_opt"
1978    )]
1979    pub timestamp: Option<SystemTime>,
1980    /// The start time of the transaction.
1981    #[serde(default = "SystemTime::now", with = "ts_seconds_float")]
1982    pub start_timestamp: SystemTime,
1983    /// The collection of finished spans part of this transaction.
1984    pub spans: Vec<Span>,
1985    /// Optional contexts.
1986    #[serde(
1987        default,
1988        skip_serializing_if = "Map::is_empty",
1989        deserialize_with = "deserialize_contexts"
1990    )]
1991    pub contexts: Map<String, Context>,
1992    /// Optionally HTTP request data to be sent along.
1993    #[serde(default, skip_serializing_if = "Option::is_none")]
1994    pub request: Option<Request>,
1995    /// Optionally the server (or device) name of this event.
1996    #[serde(default, skip_serializing_if = "Option::is_none")]
1997    pub server_name: Option<Cow<'a, str>>,
1998}
1999
2000impl Default for Transaction<'_> {
2001    fn default() -> Self {
2002        Transaction {
2003            event_id: event::default_id(),
2004            name: Default::default(),
2005            user: Default::default(),
2006            tags: Default::default(),
2007            extra: Default::default(),
2008            release: Default::default(),
2009            environment: Default::default(),
2010            sdk: Default::default(),
2011            platform: event::default_platform(),
2012            timestamp: Default::default(),
2013            start_timestamp: SystemTime::now(),
2014            spans: Default::default(),
2015            contexts: Default::default(),
2016            request: Default::default(),
2017            server_name: Default::default(),
2018        }
2019    }
2020}
2021
2022impl<'a> Transaction<'a> {
2023    /// Creates a new span transaction the current timestamp and random id.
2024    pub fn new() -> Transaction<'a> {
2025        Default::default()
2026    }
2027
2028    /// Creates a fully owned version of the transaction.
2029    pub fn into_owned(self) -> Transaction<'static> {
2030        Transaction {
2031            event_id: self.event_id,
2032            name: self.name,
2033            user: self.user,
2034            tags: self.tags,
2035            extra: self.extra,
2036            release: self.release.map(|x| Cow::Owned(x.into_owned())),
2037            environment: self.environment.map(|x| Cow::Owned(x.into_owned())),
2038            sdk: self.sdk.map(|x| Cow::Owned(x.into_owned())),
2039            platform: Cow::Owned(self.platform.into_owned()),
2040            timestamp: self.timestamp,
2041            start_timestamp: self.start_timestamp,
2042            spans: self.spans,
2043            contexts: self.contexts,
2044            request: self.request,
2045            server_name: self.server_name.map(|x| Cow::Owned(x.into_owned())),
2046        }
2047    }
2048
2049    /// Finalizes the transaction to be dispatched.
2050    pub fn finish(&mut self) {
2051        self.timestamp = Some(SystemTime::now());
2052    }
2053}
2054
2055impl fmt::Display for Transaction<'_> {
2056    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2057        write!(
2058            f,
2059            "Transaction(id: {}, ts: {})",
2060            self.event_id,
2061            crate::utils::to_rfc3339(&self.start_timestamp)
2062        )
2063    }
2064}
sentry_types/protocol/v7.rs

sentry_types/protocol/
v7.rs
