feat: Basic attachment support

sentry-core/src/client.rs

@@ -278,6 +278,13 @@ impl Client {
                         envelope.add_item(session_item);
                     }
                 }
+
+                if let Some(scope) = scope {
+                    for attachment in scope.attachments.iter().cloned() {
+                        envelope.add_item(attachment);
+                    }
+                }
+
                 transport.send_envelope(envelope);
                 return event_id;
             }

sentry-core/src/scope/real.rs

@@ -4,7 +4,7 @@ use std::fmt;
 use std::sync::{Arc, Mutex, PoisonError, RwLock};
 
 use crate::performance::TransactionOrSpan;
-use crate::protocol::{Breadcrumb, Context, Event, Level, User, Value};
+use crate::protocol::{Attachment, Breadcrumb, Context, Event, Level, User, Value};
 use crate::session::Session;
 use crate::Client;
 
@@ -46,6 +46,7 @@ pub struct Scope {
     pub(crate) event_processors: Arc<Vec<EventProcessor>>,
     pub(crate) session: Arc<Mutex<Option<Session>>>,
     pub(crate) span: Arc<Option<TransactionOrSpan>>,
+    pub(crate) attachments: Arc<Vec<Attachment>>,
 }
 
 impl fmt::Debug for Scope {
@@ -218,6 +219,16 @@ impl Scope {
         Arc::make_mut(&mut self.event_processors).push(Arc::new(f));
     }
 
+    /// Adds an attachment to the scope
+    pub fn add_attachment(&mut self, attachment: Attachment) {
+        Arc::make_mut(&mut self.attachments).push(attachment);
+    }
+
+    /// Clears attachments from the scope
+    pub fn clear_attachments(&mut self) {
+        Arc::make_mut(&mut self.attachments).clear();
+    }
+
     /// Applies the contained scoped data to fill an event.
     pub fn apply_to_event(&self, mut event: Event<'static>) -> Option<Event<'static>> {
         // TODO: event really should have an optional level

sentry-types/src/protocol/attachment.rs

@@ -37,13 +37,15 @@ impl AttachmentType {
     }
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Clone, PartialEq, Default)]
 /// Represents an attachment item.
 pub struct Attachment {
     /// The actual attachment data.
     pub buffer: Vec<u8>,
     /// The filename of the attachment.
     pub filename: String,
+    /// The Content Type of the attachment
+    pub content_type: Option<String>,
     /// The special type of this attachment.
     pub ty: Option<AttachmentType>,
 }
@@ -56,10 +58,14 @@ impl Attachment {
     {
         writeln!(
             writer,
-            r#"{{"type":"attachment","length":{length},"filename":"{filename}","attachment_type":"{at}"}}"#,
+            r#"{{"type":"attachment","length":{length},"filename":"{filename}","attachment_type":"{at}","content_type":"{ct}"}}"#,
             filename = self.filename,
             length = self.buffer.len(),
-            at = self.ty.unwrap_or_default().as_str()
+            at = self.ty.unwrap_or_default().as_str(),
+            ct = self
+                .content_type
+                .as_ref()
+                .unwrap_or(&"application/octet-stream".to_string())
         )?;
 
         writer.write_all(&self.buffer)?;
@@ -74,6 +80,7 @@ impl fmt::Debug for Attachment {
         f.debug_struct("Attachment")
             .field("buffer", &self.buffer.len())
             .field("filename", &self.filename)
+            .field("content_type", &self.content_type)
             .field("type", &self.ty)
             .finish()
     }

sentry-types/src/protocol/envelope.rs

@@ -65,6 +65,12 @@ impl From<Transaction<'static>> for EnvelopeItem {
     }
 }
 
+impl From<Attachment> for EnvelopeItem {
+    fn from(attachment: Attachment) -> Self {
+        EnvelopeItem::Attachment(attachment)
+    }
+}
+
 /// An Iterator over the items of an Envelope.
 #[derive(Clone)]
 pub struct EnvelopeItemIter<'s> {
@@ -352,6 +358,34 @@ mod test {
             r#"{"event_id":"22d00b3f-d1b1-4b5d-8d20-49d138cd8a9c"}
 {"type":"transaction","length":200}
 {"event_id":"22d00b3fd1b14b5d8d2049d138cd8a9c","start_timestamp":1595256674.296,"spans":[{"span_id":"d42cee9fc3e74f5c","trace_id":"335e53d614474acc9f89e632b776cc28","start_timestamp":1595256674.296}]}
+"#
+        )
+    }
+
+    #[test]
+    fn test_event_with_attachment() {
+        let event_id = Uuid::parse_str("22d00b3f-d1b1-4b5d-8d20-49d138cd8a9c").unwrap();
+        let timestamp = timestamp("2020-07-20T14:51:14.296Z");
+        let event = Event {
+            event_id,
+            timestamp,
+            ..Default::default()
+        };
+        let mut envelope: Envelope = event.into();
+
+        envelope.add_item(Attachment {
+            buffer: "some content".as_bytes().to_vec(),
+            filename: "file.txt".to_string(),
+            ..Default::default()
+        });
+
+        assert_eq!(
+            to_str(envelope),
+            r#"{"event_id":"22d00b3f-d1b1-4b5d-8d20-49d138cd8a9c"}
+{"type":"event","length":74}
+{"event_id":"22d00b3fd1b14b5d8d2049d138cd8a9c","timestamp":1595256674.296}
+{"type":"attachment","length":12,"filename":"file.txt","attachment_type":"event.attachment","content_type":"application/octet-stream"}
+some content
 "#
         )
     }

sentry/tests/test_basic.rs

@@ -3,6 +3,7 @@
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
 
+use sentry::protocol::{Attachment, EnvelopeItem};
 use sentry::types::Uuid;
 
 #[test]
@@ -173,3 +174,55 @@ fn test_attached_stacktrace() {
         .flat_map(|ev| ev.threads.into_iter().filter_map(|thrd| thrd.stacktrace));
     assert_eq!(stacktraces.count(), 3);
 }
+
+#[test]
+fn test_attachment_sent_from_scope() {
+    struct TestTransport(Arc<AtomicUsize>);
+
+    impl sentry::Transport for TestTransport {
+        fn send_envelope(&self, envelope: sentry::Envelope) {
+            for item in envelope.items() {
+                if let EnvelopeItem::Attachment(attachment) = item {
+                    assert_eq!(attachment.filename, "test-file.txt");
+                    assert_eq!(attachment.buffer, vec![1, 2, 3, 4, 5, 6, 7, 8, 9]);
+                    self.0.fetch_add(1, Ordering::SeqCst);
+                }
+            }
+        }
+    }
+
+    let events = Arc::new(AtomicUsize::new(0));
+
+    let events_for_options = events.clone();
+    let options = sentry::ClientOptions {
+        dsn: "http://foo@example.com/42".parse().ok(),
+        transport: Some(Arc::new(
+            move |opts: &sentry::ClientOptions| -> Arc<dyn sentry::Transport> {
+                assert_eq!(opts.dsn.as_ref().unwrap().host(), "example.com");
+                Arc::new(TestTransport(events_for_options.clone()))
+            },
+        )),
+        ..Default::default()
+    };
+
+    sentry::Hub::run(
+        Arc::new(sentry::Hub::new(
+            Some(Arc::new(options.into())),
+            Arc::new(Default::default()),
+        )),
+        || {
+            sentry::with_scope(
+                |scope| {
+                    scope.add_attachment(Attachment {
+                        buffer: vec![1, 2, 3, 4, 5, 6, 7, 8, 9],
+                        filename: "test-file.txt".to_string(),
+                        ..Default::default()
+                    })
+                },
+                || sentry::capture_message("test", sentry::Level::Error),
+            )
+        },
+    );
+
+    assert_eq!(events.load(Ordering::SeqCst), 1);
+}