Merge pull request #3 from getsentry/feature/upload-event-attachment

feat: Upload event attachment

.gitignore

@@ -7,4 +7,6 @@ example
 *.dylib
 *.dSYM
 *.mp
-*.dmp
+*.dmp
+.sentryclirc
+.venv/

.vscode/settings.json

@@ -65,6 +65,8 @@
         "optional": "cpp",
         "unordered_map": "cpp",
         "unordered_set": "cpp",
-        "mpack.c": "cpp"
+        "mpack.c": "cpp",
+        "numeric": "cpp",
+        "random": "cpp"
     }
 }

Makefile

@@ -13,4 +13,4 @@ example: example.c libsentry.dylib
 	gcc -g -o example example.c -I ./include -L . -lsentry
 build-example: example
 clean:
-	rm -rf example libsentry.dylib completed new pending *.dSYM *.mp *.dmp *.dat
+	rm -rf example libsentry.dylib crashpad-db *.dSYM *.mp

example.c

@@ -9,7 +9,7 @@ int main(void) {
     option.environment = "Production";
     option.release = "5fd7a6cd";
     option.dist = "12345";
-    option.database_path = ".";
+    option.database_path = "crashpad-db";
     option.debug = 1;
 
     sentry_init(&option);

src/crashpad_wrapper.cpp

@@ -17,7 +17,9 @@ namespace sentry {
 namespace crashpad {
 SimpleStringDictionary simple_annotations;
 
-int init(const sentry_options_t *options, const char *minidump_url) {
+int init(const sentry_options_t *options,
+         const char *minidump_url,
+         const char *event_file) {
     if (minidump_url == nullptr) {
         return SENTRY_ERROR_NO_MINIDUMP_URL;
     }
@@ -29,15 +31,19 @@ int init(const sentry_options_t *options, const char *minidump_url) {
     std::string url(minidump_url);
     // Optional annotations passed via --annotations to the handler
     std::map<std::string, std::string> annotations;
+    std::map<std::string, base::FilePath> fileAttachments = {
+        {SENTRY_EVENT_FILE_NAME, base::FilePath(event_file)}};
+
     // Optional arguments to pass to the handler
     std::vector<std::string> arguments;
     arguments.push_back("--no-rate-limit");
 
     CrashpadClient client;
-    bool success = client.StartHandler(handler, database, database, url,
-                                       annotations, arguments,
-                                       /* restartable */ true,
-                                       /* asynchronous_start */ false);
+    bool success = client.StartHandlerWithAttachments(
+        handler, database, database, url, annotations, fileAttachments,
+        arguments,
+        /* restartable */ true,
+        /* asynchronous_start */ false);
 
     if (success) {
         SENTRY_PRINT_DEBUG("Started client handler.\n");

src/crashpad_wrapper.hpp

@@ -2,7 +2,9 @@
 
 namespace sentry {
 namespace crashpad {
-int init(const sentry_options_t *options, const char *minidump_url);
+int init(const sentry_options_t *options,
+         const char *minidump_url,
+         const char *event_file);
 int set_annotation(const char *key, const char *value);
 int remove_annotation(const char *key);
 }  // namespace crashpad

src/internal.hpp

@@ -4,4 +4,6 @@
 
 const sentry_options_t *sentry__get_options(void);
 
+static const char *SENTRY_EVENT_FILE_NAME = "sentry-event.mp";
+
 #endif

src/sentry.cpp

@@ -3,10 +3,13 @@
 #elif defined(SENTRY_BREAKPAD)
 #include "breakpad_wrapper.hpp"
 #endif
+#include <sys/stat.h>
 #include <map>
+#include <sstream>
 #include <string>
 #include "internal.hpp"
 #include "print_macros.hpp"
+#include "random"
 #include "sentry.h"
 #include "vendor/mpack.h"
 
@@ -16,8 +19,6 @@ using namespace sentry::crashpad;
 using namespace sentry::breakpad;
 #endif
 
-static const char *SENTRY_EVENT_FILE_NAME = "sentry-event.mp";
-
 struct SentryDsn {
     const char *scheme;
     const char *public_key;
@@ -36,6 +37,8 @@ struct SentryEvent {
     std::map<std::string, std::string> user;
     std::map<std::string, std::string> tags;
     std::map<std::string, std::string> extra;
+    std::string run_id;
+    std::string run_path;
 };
 
 static SentryEvent sentry_event = {
@@ -143,7 +146,10 @@ static int minidump_url_from_dsn(char *dsn, std::string &minidump_url_out) {
 static void serialize(const SentryEvent *event) {
     mpack_writer_t writer;
     // TODO: cycle event file
-    mpack_writer_init_filename(&writer, SENTRY_EVENT_FILE_NAME);
+    // Path must exist otherwise mpack will fail to write.
+    auto dest_path = (event->run_path + SENTRY_EVENT_FILE_NAME).c_str();
+    SENTRY_PRINT_DEBUG_ARGS("Serializing to file: %s\n", dest_path);
+    mpack_writer_init_filename(&writer, dest_path);
     mpack_start_map(&writer, 8);
     mpack_write_cstr(&writer, "release");
     mpack_write_cstr_or_nil(&writer, event->release);
@@ -206,6 +212,7 @@ static void serialize(const SentryEvent *event) {
 
 int sentry_init(const sentry_options_t *options) {
     sentry_options = options;
+
     if (options->dsn == nullptr) {
         SENTRY_PRINT_ERROR("Not DSN specified. Sentry SDK will be disabled.\n");
         return SENTRY_ERROR_NO_DSN;
@@ -219,12 +226,8 @@ int sentry_init(const sentry_options_t *options) {
         return err;
     }
 
-    if (options->debug) {
-        SENTRY_PRINT_DEBUG_ARGS("Initializing with minidump endpoint: %s\n",
-                                minidump_url.c_str());
-    }
-
-    err = init(options, minidump_url.c_str());
+    SENTRY_PRINT_DEBUG_ARGS("Initializing with minidump endpoint: %s\n",
+                            minidump_url.c_str());
 
     if (options->environment != nullptr) {
         sentry_event.environment = options->environment;
@@ -238,6 +241,31 @@ int sentry_init(const sentry_options_t *options) {
         sentry_event.dist = options->dist;
     }
 
+    std::random_device seed;
+    std::default_random_engine engine(seed());
+    std::uniform_int_distribution<int> uniform_dist(0, INT32_MAX);
+    std::time_t result = std::time(nullptr);
+    std::stringstream ss;
+    ss << result << "-" << uniform_dist(engine);
+    sentry_event.run_id = ss.str();
+
+    /* Make sure run dir exists before serializer needs to write to it */
+    /* TODO: Write proper x-plat mkdir */
+    auto run_path = std::string(options->database_path);
+    mkdir(run_path.c_str(), 0700);
+    run_path = run_path + "/" + "sentry-runs/";
+    mkdir(run_path.c_str(), 0700);
+    sentry_event.run_path = run_path + sentry_event.run_id + "/";
+    auto rv = mkdir(sentry_event.run_path.c_str(), 0700);
+    if (rv != 0 && rv != EEXIST) {
+        SENTRY_PRINT_ERROR_ARGS("Failed to create sentry_runs directory '%s'\n",
+                                sentry_event.run_path.c_str());
+        return rv;
+    }
+
+    err = init(options, minidump_url.c_str(),
+               (sentry_event.run_path + SENTRY_EVENT_FILE_NAME).c_str());
+
     return 0;
 }