feat(native): consent-aware offline caching (#1649)

jpnurmi · claude · web-flow · commit 8edeff945b0f · 2026-04-24T14:16:51.000+02:00
Co-authored-by: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/examples/example.c b/examples/example.c
@@ -699,7 +699,7 @@ main(int argc, char **argv)
     }
     if (has_arg(argc, argv, "cache-keep")) {
         sentry_options_set_cache_keep(options, true);
-        sentry_options_set_cache_max_size(options, 4 * 1024 * 1024); // 4 MB
+        sentry_options_set_cache_max_size(options, 16 * 1024 * 1024); // 16 MB
         sentry_options_set_cache_max_age(options, 5 * 24 * 60 * 60); // 5 days
         sentry_options_set_cache_max_items(options, 5);
     }
diff --git a/src/backends/native/sentry_crash_context.h b/src/backends/native/sentry_crash_context.h
@@ -273,6 +273,11 @@ typedef struct {
     bool debug_enabled; // Debug logging enabled in parent process
     bool attach_screenshot; // Screenshot attachment enabled in parent process
     bool cache_keep;
+    bool require_user_consent;
+
+    // Atomic user consent (sentry_user_consent_t), updated whenever user
+    // consent changes so the daemon can honor it at crash time.
+    volatile long user_consent;
 
     // Platform-specific crash context
 #if defined(SENTRY_PLATFORM_LINUX) || defined(SENTRY_PLATFORM_ANDROID)
diff --git a/src/backends/native/sentry_crash_daemon.c b/src/backends/native/sentry_crash_daemon.c
@@ -2911,6 +2911,11 @@ sentry__process_crash(const sentry_options_t *options, sentry_crash_ipc_t *ipc)
     }
 #endif
 
+    if (options->run) {
+        sentry__atomic_store(&options->run->user_consent,
+            sentry__atomic_fetch(&ctx->user_consent));
+    }
+
     sentry_path_t *env_path = sentry__path_from_str(envelope_path);
     if (!env_path) {
         SENTRY_WARN("Failed to create envelope path");
@@ -2925,15 +2930,14 @@ sentry__process_crash(const sentry_options_t *options, sentry_crash_ipc_t *ipc)
         goto cleanup;
     }
 
-    SENTRY_DEBUG("Envelope loaded, sending via transport");
+    SENTRY_DEBUG("Envelope loaded, capturing");
 
-    // Send directly via transport, or to external crash reporter
+    // Capture directly, or pass to external crash reporter
     if (!sentry__launch_external_crash_reporter(options, envelope)) {
-        // Send directly via transport
-        if (options && options->transport) {
-            SENTRY_DEBUG("Calling transport send_envelope");
-            sentry__transport_send_envelope(options->transport, envelope);
-            SENTRY_DEBUG("Crash envelope sent to transport (queued)");
+        if (options && options->transport && options->run) {
+            SENTRY_DEBUG("Capturing crash envelope");
+            sentry__capture_envelope(options->transport, envelope, options);
+            SENTRY_DEBUG("Crash envelope captured (queued)");
         } else {
             SENTRY_WARN("No transport available for sending envelope");
             sentry_envelope_free(envelope);
@@ -2954,7 +2958,7 @@ sentry__process_crash(const sentry_options_t *options, sentry_crash_ipc_t *ipc)
 
 cleanup:
     // Send all other envelopes from run folder (logs, etc.) before cleanup
-    if (run_folder && options && options->transport) {
+    if (run_folder && options && options->transport && options->run) {
         SENTRY_DEBUG("Checking for additional envelopes in run folder");
         sentry_pathiter_t *piter = sentry__path_iter_directory(run_folder);
         if (piter) {
@@ -2971,8 +2975,8 @@ sentry__process_crash(const sentry_options_t *options, sentry_crash_ipc_t *ipc)
                     sentry_envelope_t *run_envelope
                         = sentry__envelope_from_path(file_path);
                     if (run_envelope) {
-                        sentry__transport_send_envelope(
-                            options->transport, run_envelope);
+                        sentry__capture_envelope(
+                            options->transport, run_envelope, options);
                         envelope_count++;
                     } else {
                         SENTRY_WARNF("Failed to load envelope: %s", path_str);
@@ -3216,6 +3220,10 @@ sentry__crash_daemon_main(pid_t app_pid, uint64_t app_tid, HANDLE event_handle,
     sentry_path_t *db_path = sentry__path_from_str(ipc->shmem->database_path);
     if (db_path) {
         options->run = sentry__run_new(db_path);
+        if (options->run) {
+            options->run->require_user_consent
+                = ipc->shmem->require_user_consent;
+        }
         sentry__path_free(db_path);
     }
 
diff --git a/src/backends/sentry_backend_breakpad.cpp b/src/backends/sentry_backend_breakpad.cpp
@@ -205,7 +205,7 @@ breakpad_backend_callback(const google_breakpad::MinidumpDescriptor &descriptor,
                 // capture the envelope with the disk transport
                 sentry_transport_t *disk_transport
                     = sentry_new_disk_transport(options->run);
-                sentry__capture_envelope(disk_transport, envelope);
+                sentry__capture_envelope(disk_transport, envelope, options);
                 sentry__transport_dump_queue(disk_transport, options->run);
                 sentry_transport_free(disk_transport);
             }
diff --git a/src/backends/sentry_backend_crashpad.cpp b/src/backends/sentry_backend_crashpad.cpp
@@ -382,7 +382,7 @@ crashpad_handler(int signum, siginfo_t *info, ucontext_t *user_context)
                 // capture the envelope with the disk transport
                 sentry_transport_t *disk_transport
                     = sentry_new_disk_transport(options->run);
-                sentry__capture_envelope(disk_transport, envelope);
+                sentry__capture_envelope(disk_transport, envelope, options);
                 sentry__transport_dump_queue(disk_transport, options->run);
                 sentry_transport_free(disk_transport);
             }
diff --git a/src/backends/sentry_backend_inproc.c b/src/backends/sentry_backend_inproc.c
@@ -1206,7 +1206,7 @@ process_ucontext_deferred(const sentry_ucontext_t *uctx,
                 // capture the envelope with the disk transport
                 sentry_transport_t *disk_transport
                     = sentry_new_disk_transport(options->run);
-                sentry__capture_envelope(disk_transport, envelope);
+                sentry__capture_envelope(disk_transport, envelope, options);
                 sentry__transport_dump_queue(disk_transport, options->run);
                 sentry_transport_free(disk_transport);
             }
diff --git a/src/backends/sentry_backend_native.c b/src/backends/sentry_backend_native.c
@@ -193,6 +193,9 @@ native_backend_startup(
     ctx->debug_enabled = options->debug;
     ctx->attach_screenshot = options->attach_screenshot;
     ctx->cache_keep = options->cache_keep;
+    ctx->require_user_consent = options->require_user_consent;
+    sentry__atomic_store(
+        &ctx->user_consent, sentry__atomic_fetch(&options->run->user_consent));
 
     // Set up event and breadcrumb paths
     sentry_path_t *run_path = options->run->run_path;
@@ -550,6 +553,21 @@ native_backend_shutdown(sentry_backend_t *backend)
     SENTRY_DEBUG("native backend shutdown complete");
 }
 
+static void
+native_backend_user_consent_changed(sentry_backend_t *backend)
+{
+    native_backend_state_t *state = (native_backend_state_t *)backend->data;
+    if (!state || !state->ipc || !state->ipc->shmem) {
+        return;
+    }
+    SENTRY_WITH_OPTIONS (options) {
+        if (options->run) {
+            sentry__atomic_store(&state->ipc->shmem->user_consent,
+                sentry__atomic_fetch(&options->run->user_consent));
+        }
+    }
+}
+
 static void
 native_backend_free(sentry_backend_t *backend)
 {
@@ -941,7 +959,8 @@ native_backend_except(sentry_backend_t *backend, const sentry_ucontext_t *uctx)
                         if (disk_transport) {
                             // sentry__capture_envelope takes ownership of
                             // envelope
-                            sentry__capture_envelope(disk_transport, envelope);
+                            sentry__capture_envelope(
+                                disk_transport, envelope, options);
                             sentry__transport_dump_queue(
                                 disk_transport, options->run);
                             sentry_transport_free(disk_transport);
@@ -988,6 +1007,7 @@ sentry__backend_new(void)
     backend->flush_scope_func = native_backend_flush_scope;
     backend->add_breadcrumb_func = native_backend_add_breadcrumb;
     backend->add_attachment_func = native_backend_add_attachment;
+    backend->user_consent_changed_func = native_backend_user_consent_changed;
     backend->can_capture_after_shutdown = false;
 
     return backend;
diff --git a/src/sentry_core.c b/src/sentry_core.c
@@ -482,22 +482,20 @@ sentry_user_consent_is_required(void)
 }
 
 void
-sentry__capture_envelope(
-    sentry_transport_t *transport, sentry_envelope_t *envelope)
+sentry__capture_envelope(sentry_transport_t *transport,
+    sentry_envelope_t *envelope, const sentry_options_t *options)
 {
-    if (!sentry__should_skip_upload()) {
+    if (!sentry__run_should_skip_upload(options->run)) {
         sentry__transport_send_envelope(transport, envelope);
         return;
     }
     bool cached = false;
-    SENTRY_WITH_OPTIONS (options) {
-        if (options->cache_keep || options->http_retry) {
-            cached = sentry__run_write_cache(options->run, envelope, 0);
-            if (cached && !sentry__run_should_skip_upload(options->run)) {
-                // consent given meanwhile -> trigger retry to avoid waiting
-                // until the next retry poll
-                sentry_transport_retry(options->transport);
-            }
+    if (options->cache_keep || options->http_retry) {
+        cached = sentry__run_write_cache(options->run, envelope, 0);
+        if (cached && !sentry__run_should_skip_upload(options->run)) {
+            // consent given meanwhile -> trigger retry to avoid waiting
+            // until the next retry poll
+            sentry_transport_retry(options->transport);
         }
     }
     SENTRY_INFO(cached ? "caching envelope due to missing user consent"
@@ -512,7 +510,7 @@ sentry_capture_envelope(sentry_envelope_t *envelope)
         return;
     }
     SENTRY_WITH_OPTIONS (options) {
-        sentry__capture_envelope(options->transport, envelope);
+        sentry__capture_envelope(options->transport, envelope, options);
     }
 }
 
@@ -621,7 +619,7 @@ sentry__capture_event(sentry_value_t event, sentry_scope_t *local_scope)
                     SENTRY_DATA_CATEGORY_ERROR, 1);
                 sentry_envelope_free(envelope);
             } else {
-                sentry__capture_envelope(options->transport, envelope);
+                sentry__capture_envelope(options->transport, envelope, options);
                 was_sent = true;
             }
         }
@@ -1630,7 +1628,7 @@ sentry_capture_user_feedback(sentry_value_t user_report)
     SENTRY_WITH_OPTIONS (options) {
         envelope = prepare_user_report(user_report);
         if (envelope) {
-            sentry__capture_envelope(options->transport, envelope);
+            sentry__capture_envelope(options->transport, envelope, options);
         }
     }
     sentry_value_decref(user_report);
@@ -1652,7 +1650,7 @@ sentry_capture_feedback_with_hint(
     SENTRY_WITH_OPTIONS (options) {
         envelope = prepare_user_feedback(user_feedback, hint);
         if (envelope) {
-            sentry__capture_envelope(options->transport, envelope);
+            sentry__capture_envelope(options->transport, envelope, options);
         }
     }
 
@@ -1765,7 +1763,7 @@ sentry_capture_minidump_n(const char *path, size_t path_len)
                 sentry__envelope_item_set_header(item, "filename",
                     sentry_value_new_string(sentry__path_filename(dump_path)));
 
-                sentry__capture_envelope(options->transport, envelope);
+                sentry__capture_envelope(options->transport, envelope, options);
 
                 SENTRY_INFOF(
                     "Minidump has been captured: \"%s\"", dump_path->path);
diff --git a/src/sentry_core.h b/src/sentry_core.h
@@ -93,8 +93,8 @@ sentry_envelope_t *sentry__prepare_transaction(const sentry_options_t *options,
  * This function will submit the `envelope` to the given `transport`, first
  * checking for consent.
  */
-void sentry__capture_envelope(
-    sentry_transport_t *transport, sentry_envelope_t *envelope);
+void sentry__capture_envelope(sentry_transport_t *transport,
+    sentry_envelope_t *envelope, const sentry_options_t *options);
 
 /**
  * Generates a new random UUID for events.
diff --git a/src/sentry_database.c b/src/sentry_database.c
@@ -451,15 +451,16 @@ sentry__process_old_runs(const sentry_options_t *options, uint64_t last_crash)
                     sentry__session_free(session);
                     if ((++session_num) >= SENTRY_MAX_ENVELOPE_SESSIONS) {
                         sentry__capture_envelope(
-                            options->transport, session_envelope);
+                            options->transport, session_envelope, options);
                         session_envelope = NULL;
                         session_num = 0;
                     }
                 }
             } else if (sentry__path_ends_with(file, ".envelope")) {
                 sentry_envelope_t *envelope = sentry__envelope_from_path(file);
                 if (envelope) {
-                    sentry__capture_envelope(options->transport, envelope);
+                    sentry__capture_envelope(
+                        options->transport, envelope, options);
                 }
             }
 
@@ -473,7 +474,7 @@ sentry__process_old_runs(const sentry_options_t *options, uint64_t last_crash)
     sentry__pathiter_free(db_iter);
 
     if (session_envelope) {
-        sentry__capture_envelope(options->transport, session_envelope);
+        sentry__capture_envelope(options->transport, session_envelope, options);
     }
 }
 
diff --git a/src/sentry_session.c b/src/sentry_session.c
@@ -268,7 +268,7 @@ sentry__capture_session(sentry_session_t *session)
     sentry__envelope_add_session(envelope, session);
 
     SENTRY_WITH_OPTIONS (options) {
-        sentry__capture_envelope(options->transport, envelope);
+        sentry__capture_envelope(options->transport, envelope, options);
     }
 }
 
diff --git a/tests/test_integration_cache.py b/tests/test_integration_cache.py
@@ -94,14 +94,14 @@ def test_cache_max_size(cmake, backend, unreachable_dsn):
         env=env,
     )
 
-    # 5 x 2mb
+    # 5 x 4mb
     assert cache_dir.exists()
     cache_files = list(cache_dir.glob("*.envelope"))
     for f in cache_files:
         with open(f, "r+b") as file:
-            file.truncate(2 * 1024 * 1024)
+            file.truncate(4 * 1024 * 1024)
 
-    # max 4mb
+    # max 16mb
     run(
         tmp_path,
         "sentry_example",
@@ -110,8 +110,8 @@ def test_cache_max_size(cmake, backend, unreachable_dsn):
     )
 
     cache_files = list(cache_dir.glob("*.envelope"))
-    assert len(cache_files) <= 2
-    assert sum(f.stat().st_size for f in cache_files) <= 4 * 1024 * 1024
+    assert len(cache_files) <= 4
+    assert sum(f.stat().st_size for f in cache_files) <= 16 * 1024 * 1024
 
 
 @pytest.mark.parametrize(
diff --git a/tests/test_integration_crashpad.py b/tests/test_integration_crashpad.py
@@ -871,7 +871,7 @@ def test_crashpad_cache_max_size(cmake, httpserver):
     cache_dir = tmp_path.joinpath(".sentry-native/cache")
     env = dict(os.environ, SENTRY_DSN=make_dsn(httpserver))
 
-    # 5 x 2mb
+    # 5 x 4mb
     for i in range(5):
         httpserver.expect_oneshot_request("/api/123456/minidump/").respond_with_data(
             "OK"
@@ -906,7 +906,7 @@ def test_crashpad_cache_max_size(cmake, httpserver):
         if cache_dir.exists():
             for f in cache_dir.glob("*.envelope"):
                 with open(f, "r+b") as file:
-                    file.truncate(2 * 1024 * 1024)
+                    file.truncate(4 * 1024 * 1024)
 
     run(
         tmp_path,
@@ -915,11 +915,11 @@ def test_crashpad_cache_max_size(cmake, httpserver):
         env=env,
     )
 
-    # max 4mb
+    # max 16mb
     assert cache_dir.exists()
     cache_files = list(cache_dir.glob("*.envelope"))
-    assert len(cache_files) <= 2
-    assert sum(f.stat().st_size for f in cache_files) <= 4 * 1024 * 1024
+    assert len(cache_files) <= 4
+    assert sum(f.stat().st_size for f in cache_files) <= 16 * 1024 * 1024
 
 
 def test_crashpad_cache_max_age(cmake, httpserver):
diff --git a/tests/test_integration_native.py b/tests/test_integration_native.py

Original file line number	Diff line number	Diff line change
`@@ -699,7 +699,7 @@ main(int argc, char **argv)`
`699`	`699`	`}`
`700`	`700`	`if (has_arg(argc, argv, "cache-keep")) {`
`701`	`701`	`sentry_options_set_cache_keep(options, true);`
`702`		`- sentry_options_set_cache_max_size(options, 4 * 1024 * 1024); // 4 MB`
	`702`	`+ sentry_options_set_cache_max_size(options, 16 * 1024 * 1024); // 16 MB`
`703`	`703`	`sentry_options_set_cache_max_age(options, 5 * 24 * 60 * 60); // 5 days`
`704`	`704`	`sentry_options_set_cache_max_items(options, 5);`
`705`	`705`	`}`
Original file line number	Diff line number	Diff line change
`@@ -205,7 +205,7 @@ breakpad_backend_callback(const google_breakpad::MinidumpDescriptor &descriptor,`
`205`	`205`	`// capture the envelope with the disk transport`
`206`	`206`	`sentry_transport_t *disk_transport`
`207`	`207`	`= sentry_new_disk_transport(options->run);`
`208`		`- sentry__capture_envelope(disk_transport, envelope);`
	`208`	`+ sentry__capture_envelope(disk_transport, envelope, options);`
`209`	`209`	`sentry__transport_dump_queue(disk_transport, options->run);`
`210`	`210`	`sentry_transport_free(disk_transport);`
`211`	`211`	`}`
Original file line number	Diff line number	Diff line change
`@@ -382,7 +382,7 @@ crashpad_handler(int signum, siginfo_t info, ucontext_t user_context)`
`382`	`382`	`// capture the envelope with the disk transport`
`383`	`383`	`sentry_transport_t *disk_transport`
`384`	`384`	`= sentry_new_disk_transport(options->run);`
`385`		`- sentry__capture_envelope(disk_transport, envelope);`
	`385`	`+ sentry__capture_envelope(disk_transport, envelope, options);`
`386`	`386`	`sentry__transport_dump_queue(disk_transport, options->run);`
`387`	`387`	`sentry_transport_free(disk_transport);`
`388`	`388`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1206,7 +1206,7 @@ process_ucontext_deferred(const sentry_ucontext_t *uctx,`
`1206`	`1206`	`// capture the envelope with the disk transport`
`1207`	`1207`	`sentry_transport_t *disk_transport`
`1208`	`1208`	`= sentry_new_disk_transport(options->run);`
`1209`		`- sentry__capture_envelope(disk_transport, envelope);`
	`1209`	`+ sentry__capture_envelope(disk_transport, envelope, options);`
`1210`	`1210`	`sentry__transport_dump_queue(disk_transport, options->run);`
`1211`	`1211`	`sentry_transport_free(disk_transport);`
`1212`	`1212`	`}`
Original file line number	Diff line number	Diff line change
`@@ -482,22 +482,20 @@ sentry_user_consent_is_required(void)`
`482`	`482`	`}`
`483`	`483`
`484`	`484`	`void`
`485`		`-sentry__capture_envelope(`
`486`		`- sentry_transport_t transport, sentry_envelope_t envelope)`
	`485`	`+sentry__capture_envelope(sentry_transport_t *transport,`
	`486`	`+ sentry_envelope_t envelope, const sentry_options_t options)`
`487`	`487`	`{`
`488`		`- if (!sentry__should_skip_upload()) {`
	`488`	`+ if (!sentry__run_should_skip_upload(options->run)) {`
`489`	`489`	`sentry__transport_send_envelope(transport, envelope);`
`490`	`490`	`return;`
`491`	`491`	`}`
`492`	`492`	`bool cached = false;`
`493`		`- SENTRY_WITH_OPTIONS (options) {`
`494`		`- if (options->cache_keep \|\| options->http_retry) {`
`495`		`- cached = sentry__run_write_cache(options->run, envelope, 0);`
`496`		`- if (cached && !sentry__run_should_skip_upload(options->run)) {`
`497`		`- // consent given meanwhile -> trigger retry to avoid waiting`
`498`		`- // until the next retry poll`
`499`		`- sentry_transport_retry(options->transport);`
`500`		`- }`
	`493`	`+ if (options->cache_keep \|\| options->http_retry) {`
	`494`	`+ cached = sentry__run_write_cache(options->run, envelope, 0);`
	`495`	`+ if (cached && !sentry__run_should_skip_upload(options->run)) {`
	`496`	`+ // consent given meanwhile -> trigger retry to avoid waiting`
	`497`	`+ // until the next retry poll`
	`498`	`+ sentry_transport_retry(options->transport);`
`501`	`499`	`}`
`502`	`500`	`}`
`503`	`501`	`SENTRY_INFO(cached ? "caching envelope due to missing user consent"`
`@@ -512,7 +510,7 @@ sentry_capture_envelope(sentry_envelope_t *envelope)`
`512`	`510`	`return;`
`513`	`511`	`}`
`514`	`512`	`SENTRY_WITH_OPTIONS (options) {`
`515`		`- sentry__capture_envelope(options->transport, envelope);`
	`513`	`+ sentry__capture_envelope(options->transport, envelope, options);`
`516`	`514`	`}`
`517`	`515`	`}`
`518`	`516`
`@@ -621,7 +619,7 @@ sentry__capture_event(sentry_value_t event, sentry_scope_t *local_scope)`
`621`	`619`	`SENTRY_DATA_CATEGORY_ERROR, 1);`
`622`	`620`	`sentry_envelope_free(envelope);`
`623`	`621`	`} else {`
`624`		`- sentry__capture_envelope(options->transport, envelope);`
	`622`	`+ sentry__capture_envelope(options->transport, envelope, options);`
`625`	`623`	`was_sent = true;`
`626`	`624`	`}`
`627`	`625`	`}`
`@@ -1630,7 +1628,7 @@ sentry_capture_user_feedback(sentry_value_t user_report)`
`1630`	`1628`	`SENTRY_WITH_OPTIONS (options) {`
`1631`	`1629`	`envelope = prepare_user_report(user_report);`
`1632`	`1630`	`if (envelope) {`
`1633`		`- sentry__capture_envelope(options->transport, envelope);`
	`1631`	`+ sentry__capture_envelope(options->transport, envelope, options);`
`1634`	`1632`	`}`
`1635`	`1633`	`}`
`1636`	`1634`	`sentry_value_decref(user_report);`
`@@ -1652,7 +1650,7 @@ sentry_capture_feedback_with_hint(`
`1652`	`1650`	`SENTRY_WITH_OPTIONS (options) {`
`1653`	`1651`	`envelope = prepare_user_feedback(user_feedback, hint);`
`1654`	`1652`	`if (envelope) {`
`1655`		`- sentry__capture_envelope(options->transport, envelope);`
	`1653`	`+ sentry__capture_envelope(options->transport, envelope, options);`
`1656`	`1654`	`}`
`1657`	`1655`	`}`
`1658`	`1656`
`@@ -1765,7 +1763,7 @@ sentry_capture_minidump_n(const char *path, size_t path_len)`
`1765`	`1763`	`sentry__envelope_item_set_header(item, "filename",`
`1766`	`1764`	`sentry_value_new_string(sentry__path_filename(dump_path)));`
`1767`	`1765`
`1768`		`- sentry__capture_envelope(options->transport, envelope);`
	`1766`	`+ sentry__capture_envelope(options->transport, envelope, options);`
`1769`	`1767`
`1770`	`1768`	`SENTRY_INFOF(`
`1771`	`1769`	`"Minidump has been captured: \"%s\"", dump_path->path);`
Original file line number	Diff line number	Diff line change
`@@ -451,15 +451,16 @@ sentry__process_old_runs(const sentry_options_t *options, uint64_t last_crash)`
`451`	`451`	`sentry__session_free(session);`
`452`	`452`	`if ((++session_num) >= SENTRY_MAX_ENVELOPE_SESSIONS) {`
`453`	`453`	`sentry__capture_envelope(`
`454`		`- options->transport, session_envelope);`
	`454`	`+ options->transport, session_envelope, options);`
`455`	`455`	`session_envelope = NULL;`
`456`	`456`	`session_num = 0;`
`457`	`457`	`}`
`458`	`458`	`}`
`459`	`459`	`} else if (sentry__path_ends_with(file, ".envelope")) {`
`460`	`460`	`sentry_envelope_t *envelope = sentry__envelope_from_path(file);`
`461`	`461`	`if (envelope) {`
`462`		`- sentry__capture_envelope(options->transport, envelope);`
	`462`	`+ sentry__capture_envelope(`
	`463`	`+ options->transport, envelope, options);`
`463`	`464`	`}`
`464`	`465`	`}`
`465`	`466`
`@@ -473,7 +474,7 @@ sentry__process_old_runs(const sentry_options_t *options, uint64_t last_crash)`
`473`	`474`	`sentry__pathiter_free(db_iter);`
`474`	`475`
`475`	`476`	`if (session_envelope) {`
`476`		`- sentry__capture_envelope(options->transport, session_envelope);`
	`477`	`+ sentry__capture_envelope(options->transport, session_envelope, options);`
`477`	`478`	`}`
`478`	`479`	`}`
`479`	`480`