WIP: feat(transport): TUS upload for large attachments

CHANGELOG.md

@@ -1,6 +1,10 @@
 # Changelog
 
-## Unreleased:
+## Unreleased
+
+**Features**:
+
+- Add HTTP retry with exponential backoff. ([#1520](https://github.com/getsentry/sentry-native/pull/1520))
 
 **Fixes**:
 

CMakeLists.txt

@@ -420,6 +420,14 @@ endif()
 include(CheckTypeSize)
 check_type_size("long" CMAKE_SIZEOF_LONG)
 
+if(LINUX)
+	include(CheckSymbolExists)
+	check_symbol_exists(copy_file_range "unistd.h" HAVE_COPY_FILE_RANGE)
+	if(HAVE_COPY_FILE_RANGE)
+		target_compile_definitions(sentry PRIVATE SENTRY_HAVE_COPY_FILE_RANGE)
+	endif()
+endif()
+
 # https://gitlab.kitware.com/cmake/cmake/issues/18393
 if(SENTRY_BUILD_SHARED_LIBS)
 	if(APPLE)

examples/example.c

@@ -524,6 +524,25 @@ main(int argc, char **argv)
         sentry_options_add_attachment(options, "./CMakeCache.txt");
     }
 
+    if (has_arg(argc, argv, "large-attachment")) {
+        const char *large_file = ".sentry-large-attachment";
+        FILE *f = fopen(large_file, "wb");
+        if (f) {
+            // 100 MB = TUS upload threshold
+            char zeros[4096];
+            memset(zeros, 0, sizeof(zeros));
+            size_t remaining = 100 * 1024 * 1024;
+            while (remaining > 0) {
+                size_t chunk
+                    = remaining < sizeof(zeros) ? remaining : sizeof(zeros);
+                fwrite(zeros, 1, chunk, f);
+                remaining -= chunk;
+            }
+            fclose(f);
+            sentry_options_add_attachment(options, large_file);
+        }
+    }
+
     if (has_arg(argc, argv, "stdout")) {
         sentry_options_set_transport(
             options, sentry_transport_new(print_envelope));
@@ -659,6 +678,9 @@ main(int argc, char **argv)
         sentry_options_set_cache_max_age(options, 5 * 24 * 60 * 60); // 5 days
         sentry_options_set_cache_max_items(options, 5);
     }
+    if (has_arg(argc, argv, "no-http-retry")) {
+        sentry_options_set_http_retry(options, false);
+    }
 
     if (has_arg(argc, argv, "enable-metrics")) {
         sentry_options_set_enable_metrics(options, true);
@@ -940,6 +962,10 @@ main(int argc, char **argv)
         sentry_reinstall_backend();
     }
 
+    if (has_arg(argc, argv, "flush")) {
+        sentry_flush(10000);
+    }
+
     if (has_arg(argc, argv, "sleep")) {
         sleep_s(10);
     }

include/sentry.h

@@ -946,6 +946,24 @@ SENTRY_API void sentry_transport_set_shutdown_func(
     sentry_transport_t *transport,
     int (*shutdown_func)(uint64_t timeout, void *state));
 
+/**
+ * Retries sending all pending envelopes in the transport's retry queue,
+ * e.g. when coming back online. Only applicable for HTTP transports.
+ *
+ * Note: The SDK automatically retries failed envelopes on next application
+ * startup. This function allows manual triggering of pending retries at
+ * runtime. Each envelope is retried up to 6 times. If all attempts are
+ * exhausted during intermittent connectivity, events will be discarded
+ * (or moved to cache if enabled via sentry_options_set_cache_keep).
+ *
+ * Warning: This function has no rate limiting - it will immediately
+ * attempt to send all pending envelopes. Calling this repeatedly during
+ * extended network outages may exhaust retry attempts that might have
+ * succeeded with the SDK's built-in exponential backoff.
+ */
+SENTRY_EXPERIMENTAL_API void sentry_transport_retry(
+    sentry_transport_t *transport);
+
 /**
  * Generic way to free transport.
  */
@@ -1476,12 +1494,13 @@ SENTRY_API int sentry_options_get_symbolize_stacktraces(
     const sentry_options_t *opts);
 
 /**
- * Enables or disables storing envelopes in a persistent cache.
+ * Enables or disables storing failed envelopes in a persistent cache.
+ *
+ * When enabled, envelopes that fail to send are written to a `cache/`
+ * subdirectory within the database directory. The cache is cleared on startup
+ * based on the cache_max_items, cache_max_size, and cache_max_age options.
  *
- * When enabled, envelopes are written to a `cache/` subdirectory within the
- * database directory and retained regardless of send success or failure.
- * The cache is cleared on startup based on the cache_max_items, cache_max_size,
- * and cache_max_age options.
+ * Only applicable for HTTP transports.
  *
  * Disabled by default.
  */
@@ -2258,6 +2277,18 @@ SENTRY_EXPERIMENTAL_API void sentry_options_set_enable_logs(
 SENTRY_EXPERIMENTAL_API int sentry_options_get_enable_logs(
     const sentry_options_t *opts);
 
+/**
+ * Enables or disables HTTP retry with exponential backoff for network failures.
+ *
+ * Only applicable for HTTP transports.
+ *
+ * Enabled by default.
+ */
+SENTRY_EXPERIMENTAL_API void sentry_options_set_http_retry(
+    sentry_options_t *opts, int enabled);
+SENTRY_EXPERIMENTAL_API int sentry_options_get_http_retry(
+    const sentry_options_t *opts);
+
 /**
  * Enables or disables custom attributes parsing for structured logging.
  *

src/CMakeLists.txt

@@ -34,6 +34,8 @@ sentry_target_sources_cwd(sentry
 	sentry_process.h
 	sentry_ratelimiter.c
 	sentry_ratelimiter.h
+	sentry_retry.c
+	sentry_retry.h
 	sentry_ringbuffer.c
 	sentry_ringbuffer.h
 	sentry_sampling_context.h

src/backends/sentry_backend_breakpad.cpp

@@ -178,6 +178,16 @@ breakpad_backend_callback(const google_breakpad::MinidumpDescriptor &descriptor,
 
                 sentry__envelope_item_set_header(item, "filename",
                     sentry_value_new_string(sentry__path_filename(dump_path)));
+            } else {
+                sentry_uuid_t event_id
+                    = sentry__envelope_get_event_id(envelope);
+                sentry_attachment_t tmp;
+                memset(&tmp, 0, sizeof(tmp));
+                tmp.path = dump_path;
+                tmp.type = MINIDUMP;
+                tmp.next = nullptr;
+                sentry__cache_external_attachments(
+                    options->run->cache_path, &event_id, &tmp, nullptr);
             }
 
             if (options->attach_screenshot) {

src/backends/sentry_backend_crashpad.cpp

@@ -529,6 +529,11 @@ report_to_envelope(const crashpad::CrashReportDatabase::Report &report,
 
         if (sentry__envelope_add_event(envelope, event)) {
             sentry__envelope_add_attachments(envelope, attachments);
+            sentry_uuid_t event_id = sentry__envelope_get_event_id(envelope);
+            if (options->run) {
+                sentry__cache_external_attachments(options->run->cache_path,
+                    &event_id, attachments, options->run->run_path);
+            }
         } else {
             sentry_value_decref(event);
             sentry_envelope_free(envelope);
@@ -565,11 +570,9 @@ process_completed_reports(
 
     SENTRY_DEBUGF("caching %zu completed reports", reports.size());
 
-    sentry_path_t *cache_dir
-        = sentry__path_join_str(options->database_path, "cache");
-    if (!cache_dir || sentry__path_create_dir_all(cache_dir) != 0) {
+    sentry_path_t *cache_dir = options->run->cache_path;
+    if (sentry__path_create_dir_all(cache_dir) != 0) {
         SENTRY_WARN("failed to create cache dir");
-        sentry__path_free(cache_dir);
         return;
     }
 
@@ -593,8 +596,6 @@ process_completed_reports(
         sentry__path_free(out_path);
         sentry_envelope_free(envelope);
     }
-
-    sentry__path_free(cache_dir);
 }
 
 static int

src/backends/sentry_backend_inproc.c

@@ -1156,8 +1156,9 @@ process_ucontext_deferred(const sentry_ucontext_t *uctx,
         }
         TEST_CRASH_POINT("before_capture");
         if (should_handle) {
+            sentry_uuid_t event_id;
             sentry_envelope_t *envelope = sentry__prepare_event(options, event,
-                NULL, !options->on_crash_func && !skip_hooks, NULL);
+                &event_id, !options->on_crash_func && !skip_hooks, NULL);
             // TODO(tracing): Revisit when investigating transaction flushing
             //                during hard crashes.
 

src/path/sentry_path.c

@@ -79,6 +79,19 @@ sentry__path_remove_all(const sentry_path_t *path)
     return sentry__path_remove(path);
 }
 
+size_t
+sentry__path_get_dir_size(const sentry_path_t *path)
+{
+    size_t total = 0;
+    sentry_pathiter_t *iter = sentry__path_iter_directory(path);
+    const sentry_path_t *entry;
+    while (iter && (entry = sentry__pathiter_next(iter)) != NULL) {
+        total += sentry__path_get_size(entry);
+    }
+    sentry__pathiter_free(iter);
+    return total;
+}
+
 sentry_filelock_t *
 sentry__filelock_new(sentry_path_t *path)
 {

src/path/sentry_path_unix.c

@@ -21,6 +21,7 @@
 #include <unistd.h>
 
 #ifdef SENTRY_PLATFORM_DARWIN
+#    include <copyfile.h>
 #    include <mach-o/dyld.h>
 #endif
 
@@ -333,6 +334,71 @@ sentry__path_rename(const sentry_path_t *src, const sentry_path_t *dst)
     return status == 0 ? 0 : 1;
 }
 
+int
+sentry__path_copy(const sentry_path_t *src, const sentry_path_t *dst)
+{
+#ifdef SENTRY_PLATFORM_DARWIN
+    return copyfile(src->path, dst->path, NULL, COPYFILE_DATA) == 0 ? 0 : 1;
+#else
+    int src_fd = open(src->path, O_RDONLY);
+    if (src_fd < 0) {
+        return 1;
+    }
+    int dst_fd = open(dst->path, O_WRONLY | O_CREAT | O_TRUNC,
+        S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
+    if (dst_fd < 0) {
+        close(src_fd);
+        return 1;
+    }
+
+    int rv = 0;
+
+#    ifdef SENTRY_HAVE_COPY_FILE_RANGE
+    while (true) {
+        ssize_t n
+            = copy_file_range(src_fd, NULL, dst_fd, NULL, SIZE_MAX / 2, 0);
+        if (n > 0) {
+            continue;
+        } else if (n == 0) {
+            goto done;
+        } else if (errno == EAGAIN || errno == EINTR) {
+            continue;
+        } else if (errno == ENOSYS || errno == EXDEV || errno == EOPNOTSUPP
+            || errno == EINVAL) {
+            break;
+        } else {
+            rv = 1;
+            goto done;
+        }
+    }
+#    endif
+
+    {
+        char buf[16384];
+        while (true) {
+            ssize_t n = read(src_fd, buf, sizeof(buf));
+            if (n < 0 && (errno == EAGAIN || errno == EINTR)) {
+                continue;
+            } else if (n <= 0) {
+                rv = n < 0;
+                break;
+            }
+            if (write_loop(dst_fd, buf, (size_t)n) != 0) {
+                rv = 1;
+                break;
+            }
+        }
+    }
+
+#    ifdef SENTRY_HAVE_COPY_FILE_RANGE
+done:
+#    endif
+    close(src_fd);
+    close(dst_fd);
+    return rv;
+#endif
+}
+
 int
 sentry__path_create_dir_all(const sentry_path_t *path)
 {

src/path/sentry_path_windows.c

@@ -524,6 +524,15 @@ sentry__path_rename(const sentry_path_t *src, const sentry_path_t *dst)
     return MoveFileExW(src_w, dst_w, MOVEFILE_REPLACE_EXISTING) ? 0 : 1;
 }
 
+int
+sentry__path_copy(const sentry_path_t *src, const sentry_path_t *dst)
+{
+    if (!src->path_w || !dst->path_w) {
+        return 1;
+    }
+    return CopyFileW(src->path_w, dst->path_w, FALSE) ? 0 : 1;
+}
+
 int
 sentry__path_create_dir_all(const sentry_path_t *path)
 {

src/sentry_attachment.c

@@ -258,3 +258,32 @@ sentry__attachments_extend(
             attachments_ptr, attachment_clone(it), it->type, it->content_type);
     }
 }
+
+size_t
+sentry__attachment_get_size(const sentry_attachment_t *attachment)
+{
+    return attachment->buf ? attachment->buf_len
+                           : sentry__path_get_size(attachment->path);
+}
+
+const char *
+sentry__attachment_get_filename(const sentry_attachment_t *attachment)
+{
+    return sentry__path_filename(
+        attachment->filename ? attachment->filename : attachment->path);
+}
+
+const char *
+sentry__attachment_type_to_string(sentry_attachment_type_t attachment_type)
+{
+    switch (attachment_type) {
+    case ATTACHMENT:
+        return "event.attachment";
+    case MINIDUMP:
+        return "event.minidump";
+    case VIEW_HIERARCHY:
+        return "event.view_hierarchy";
+    default:
+        return "event.attachment";
+    }
+}