WIP: native backend TUS follow-up

Stage large attachments at crash time in the native backend's daemon
process and emit attachment-ref items into the envelope (instead of
inlining), so the transport's existing resolve_ref_items uploads via
TUS and POSTs the envelope — all from the daemon, no restart.

- attachment_is_external() / stage_external_attachment() in the daemon
- add_external_attachment_refs() called after sentry__envelope_from_path
  reuses sentry__envelope_add_attachment_ref so the daemon doesn't
  duplicate the attachment-ref byte format
- new test_tus_crash_native integration test

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jpnurmi

src/backends/native/sentry_crash_daemon.c

@@ -2,6 +2,7 @@
 
 #include "minidump/sentry_minidump_writer.h"
 #include "sentry_alloc.h"
+#include "sentry_attachment.h"
 #include "sentry_core.h"
 #include "sentry_crash_ipc.h"
 #include "sentry_database.h"
@@ -195,6 +196,123 @@ write_attachment_to_envelope(int fd, const char *file_path,
     return true;
 }
 
+// Returns true if the attachment at `file_path` should be staged to the cache
+// and emitted as an attachment-ref item rather than inlined into the envelope.
+static bool
+attachment_is_external(const char *file_path)
+{
+    sentry_path_t *src = sentry__path_from_str(file_path);
+    size_t file_size = src ? sentry__path_get_size(src) : 0;
+    sentry__path_free(src);
+    return file_size >= SENTRY_LARGE_ATTACHMENT_SIZE;
+}
+
+// Stage `src_path` as a sibling of the cached envelope at
+// <db>/cache/<event_id>-<filename> (with `-N` collision suffix). Returns the
+// chosen basename (caller frees) or NULL on failure.
+static char *
+stage_external_attachment(const char *src_path, const char *filename,
+    const char *event_id, const char *db_dir)
+{
+    char cache_dir_buf[SENTRY_CRASH_MAX_PATH];
+    int n = snprintf(cache_dir_buf, sizeof(cache_dir_buf), "%s/cache", db_dir);
+    if (n <= 0 || (size_t)n >= sizeof(cache_dir_buf)) {
+        return NULL;
+    }
+    sentry_path_t *cache_path = sentry__path_from_str(cache_dir_buf);
+    if (!cache_path || sentry__path_create_dir_all(cache_path) != 0) {
+        sentry__path_free(cache_path);
+        return NULL;
+    }
+    char buf[256];
+    snprintf(buf, sizeof(buf), "%s-%s", event_id, filename);
+    char *basename = sentry__path_unique_name(cache_path, buf);
+    if (!basename) {
+        sentry__path_free(cache_path);
+        return NULL;
+    }
+    sentry_path_t *dst = sentry__path_join_str(cache_path, basename);
+    sentry__path_free(cache_path);
+    sentry_path_t *src = sentry__path_from_str(src_path);
+    int rv = (src && dst) ? sentry__path_copy(src, dst) : -1;
+    sentry__path_free(src);
+    sentry__path_free(dst);
+    if (rv != 0) {
+        sentry_free(basename);
+        return NULL;
+    }
+    return basename;
+}
+
+// For each large attachment listed in `<run_folder>/__sentry-attachments`,
+// stage it to <db>/cache and append an `attachment-ref` item to `envelope`.
+// The transport then uploads via TUS at send time. Small attachments were
+// already inlined during envelope writing.
+static void
+add_external_attachment_refs(sentry_envelope_t *envelope,
+    const sentry_path_t *run_folder, const char *db_dir)
+{
+    if (!envelope || !run_folder || !db_dir) {
+        return;
+    }
+    sentry_path_t *attach_list_path
+        = sentry__path_join_str(run_folder, "__sentry-attachments");
+    if (!attach_list_path) {
+        return;
+    }
+    size_t attach_json_len = 0;
+    char *attach_json
+        = sentry__path_read_to_buffer(attach_list_path, &attach_json_len);
+    sentry__path_free(attach_list_path);
+    if (!attach_json) {
+        return;
+    }
+    sentry_value_t list = attach_json_len > 0
+        ? sentry__value_from_json(attach_json, attach_json_len)
+        : sentry_value_new_null();
+    sentry_free(attach_json);
+    if (sentry_value_is_null(list)) {
+        return;
+    }
+
+    sentry_uuid_t event_id = sentry__envelope_get_event_id(envelope);
+    if (sentry_uuid_is_nil(&event_id)) {
+        sentry_value_decref(list);
+        return;
+    }
+    char event_id_str[37];
+    sentry_uuid_as_string(&event_id, event_id_str);
+
+    size_t len = sentry_value_get_length(list);
+    for (size_t i = 0; i < len; i++) {
+        sentry_value_t info = sentry_value_get_by_index(list, i);
+        const char *path
+            = sentry_value_as_string(sentry_value_get_by_key(info, "path"));
+        const char *filename
+            = sentry_value_as_string(sentry_value_get_by_key(info, "filename"));
+        const char *content_type = sentry_value_as_string(
+            sentry_value_get_by_key(info, "content_type"));
+        if (!path || !*path || !filename || !*filename
+            || !attachment_is_external(path)) {
+            continue;
+        }
+        sentry_path_t *src = sentry__path_from_str(path);
+        size_t file_size = src ? sentry__path_get_size(src) : 0;
+        sentry__path_free(src);
+        char *basename
+            = stage_external_attachment(path, filename, event_id_str, db_dir);
+        if (!basename) {
+            SENTRY_WARNF("Failed to stage large attachment: %s", path);
+            continue;
+        }
+        sentry__envelope_add_attachment_ref(envelope, basename, NULL, filename,
+            (content_type && *content_type) ? content_type : NULL, ATTACHMENT,
+            sentry_value_new_uint64((uint64_t)file_size));
+        sentry_free(basename);
+    }
+    sentry_value_decref(list);
+}
+
 #if defined(SENTRY_PLATFORM_UNIX)
 /**
  * Get signal name from signal number (Unix platforms only)
@@ -2382,7 +2500,7 @@ write_envelope_with_native_stacktrace(const sentry_options_t *options,
                         const char *content_type
                             = sentry_value_as_string(content_type_val);
 
-                        if (path && filename) {
+                        if (path && filename && !attachment_is_external(path)) {
                             write_attachment_to_envelope(
                                 fd, path, filename, content_type);
                         }
@@ -2617,7 +2735,7 @@ write_envelope_with_minidump(const sentry_options_t *options,
                         const char *content_type
                             = sentry_value_as_string(content_type_val);
 
-                        if (path && filename) {
+                        if (path && filename && !attachment_is_external(path)) {
                             write_attachment_to_envelope(
                                 fd, path, filename, content_type);
                         }
@@ -2923,6 +3041,8 @@ sentry__process_crash(const sentry_options_t *options, sentry_crash_ipc_t *ipc)
         goto cleanup;
     }
 
+    add_external_attachment_refs(envelope, run_folder, db_dir);
+
     SENTRY_DEBUG("Envelope loaded, sending via transport");
 
     // Send directly via transport, or to external crash reporter

tests/test_integration_tus.py

@@ -9,7 +9,7 @@
     Envelope,
     SENTRY_VERSION,
 )
-from .conditions import has_breakpad, has_http, is_qemu
+from .conditions import has_breakpad, has_http, has_native, is_qemu
 
 pytestmark = pytest.mark.skipif(not has_http, reason="tests need http")
 
@@ -295,6 +295,76 @@ def test_tus_crash_restart(cmake, httpserver, backend):
     assert leftover_siblings == []
 
 
+@pytest.mark.skipif(not has_native or is_qemu, reason="native backend not available")
+def test_tus_crash_native(cmake, httpserver):
+    # The native backend's daemon process handles the crash out-of-process: it
+    # stages the large attachment, writes the envelope with attachment-ref
+    # items, and uploads via TUS itself. No restart needed — unlike the inproc
+    # / breakpad backends, which rely on the SDK on the next startup.
+    tmp_path = cmake(["sentry_example"], {"SENTRY_BACKEND": "native"})
+
+    upload_uri = "/api/123456/upload/abc123def456789/"
+    upload_qs = "length=104857600&signature=xyz"
+    location = httpserver.url_for(upload_uri) + "?" + upload_qs
+
+    httpserver.expect_oneshot_request(
+        "/api/123456/upload/",
+        headers={"tus-resumable": "1.0.0"},
+    ).respond_with_data("OK", status=201, headers={"Location": location})
+
+    httpserver.expect_oneshot_request(
+        upload_uri,
+        method="PATCH",
+        headers={"tus-resumable": "1.0.0"},
+        query_string=upload_qs,
+    ).respond_with_data("", status=204)
+
+    httpserver.expect_oneshot_request(
+        "/api/123456/envelope/",
+        headers={"x-sentry-auth": auth_header},
+    ).respond_with_data("OK")
+
+    env = dict(os.environ, SENTRY_DSN=make_dsn(httpserver))
+
+    with httpserver.wait(timeout=15) as waiting:
+        run(
+            tmp_path,
+            "sentry_example",
+            ["log", "large-attachment", "crash"],
+            expect_failure=True,
+            env=env,
+        )
+    assert waiting.result
+
+    create_req = upload_req = envelope_req = None
+    for entry in httpserver.log:
+        req = entry[0]
+        if req.path == "/api/123456/upload/" and req.method == "POST":
+            create_req = req
+        elif upload_uri in req.path and req.method == "PATCH":
+            upload_req = req
+        elif "/envelope/" in req.path:
+            envelope_req = req
+    assert create_req is not None
+    assert upload_req is not None
+    assert envelope_req is not None
+    assert int(create_req.headers.get("upload-length")) == 100 * 1024 * 1024
+
+    body = envelope_req.get_data()
+    envelope = Envelope.deserialize(body)
+    attachment_ref = None
+    for item in envelope:
+        if (
+            item.headers.get("content_type")
+            == "application/vnd.sentry.attachment-ref+json"
+        ):
+            if hasattr(item.payload, "json") and "location" in item.payload.json:
+                attachment_ref = item
+                break
+    assert attachment_ref is not None
+    assert attachment_ref.payload.json["location"] == location
+
+
 def test_small_attachment_no_tus(cmake, httpserver):
     tmp_path = cmake(
         ["sentry_example"],