feat(session-replay): upload replay envelope from the native crash daemon

examples/example.c

@@ -1070,6 +1070,15 @@ main(int argc, char **argv)
         sentry_set_trace(direct_trace_id, direct_parent_span_id);
     }
 
+    if (has_arg(argc, argv, "replay-context")) {
+        // mimics an embedder (e.g. sentry-unreal) that stages replay clips in
+        // `<database>/replays/` and announces the active replay on the scope
+        sentry_value_t replay = sentry_value_new_object();
+        sentry_value_set_by_key(replay, "replay_id",
+            sentry_value_new_string("deadbeefdeadbeefdeadbeefdeadbeef"));
+        sentry_set_context("replay", replay);
+    }
+
     if (has_arg(argc, argv, "attach-after-init")) {
         // assuming the example / test is run directly from the cmake build
         // directory

src/backends/native/sentry_crash_daemon.c

@@ -3340,8 +3340,6 @@ sentry__process_crash(const sentry_options_t *options, sentry_crash_ipc_t *ipc)
     SENTRY_DEBUG("Extracting run folder from event path");
     sentry_path_t *ev_path = sentry__path_from_str(event_path);
     sentry_path_t *run_folder = ev_path ? sentry__path_dir(ev_path) : NULL;
-    if (ev_path)
-        sentry__path_free(ev_path);
 
     // Acquire the run directory lock file so that process_old_runs() in a
     // new SDK run will skip this directory while the daemon is still
@@ -3369,6 +3367,7 @@ sentry__process_crash(const sentry_options_t *options, sentry_crash_ipc_t *ipc)
 
     if (path_len < 0 || path_len >= (int)sizeof(envelope_path)) {
         SENTRY_WARN("Envelope path truncated or invalid");
+        sentry__path_free(ev_path);
         if (run_folder) {
             sentry__path_free(run_folder);
         }
@@ -3472,6 +3471,7 @@ sentry__process_crash(const sentry_options_t *options, sentry_crash_ipc_t *ipc)
 
     if (!envelope_written) {
         SENTRY_WARN("Failed to write envelope");
+        sentry__path_free(ev_path);
         if (run_folder) {
             sentry__path_free(run_folder);
         }
@@ -3571,6 +3571,28 @@ sentry__process_crash(const sentry_options_t *options, sentry_crash_ipc_t *ipc)
 #endif
 
 cleanup:
+    // Send the staged session-replay envelope same-session, enriched from the
+    // crash event (`<run>/__sentry-event`) so it shares the crash's
+    // tags/contexts/trace. Only flush when the crash itself was delivered:
+    // `cleanup` is also reached via `goto` on error paths where the crash was
+    // never captured, and flushing there would consume (and delete) the staged
+    // replay for a crash that never arrived.
+    if (crash_captured && options && options->transport
+        && sentry__session_replay_has_pending(options)) {
+        sentry_value_t crash_event = sentry_value_new_null();
+        if (ev_path) {
+            size_t ev_len = 0;
+            char *ev_json = sentry__path_read_to_buffer(ev_path, &ev_len);
+            if (ev_json) {
+                crash_event = sentry__value_from_json(ev_json, ev_len);
+                sentry_free(ev_json);
+            }
+        }
+        sentry__session_replay_flush_pending(
+            options, options->transport, crash_event);
+        sentry_value_decref(crash_event);
+    }
+
     // Send all other envelopes from run folder (logs, etc.) before cleanup
     if (run_folder && options && options->transport && options->run) {
         SENTRY_DEBUG("Checking for additional envelopes in run folder");
@@ -3613,6 +3635,7 @@ sentry__process_crash(const sentry_options_t *options, sentry_crash_ipc_t *ipc)
         sentry__path_remove_all(run_folder);
         sentry__path_free(run_folder);
     }
+    sentry__path_free(ev_path);
 
     // Release and clean up the lock file
     if (run_lock) {

src/sentry_client_report.h

@@ -30,6 +30,7 @@ typedef enum {
     SENTRY_DATA_CATEGORY_LOG_ITEM,
     SENTRY_DATA_CATEGORY_FEEDBACK,
     SENTRY_DATA_CATEGORY_TRACE_METRIC,
+    SENTRY_DATA_CATEGORY_REPLAY,
     SENTRY_DATA_CATEGORY_MAX
 } sentry_data_category_t;
 

src/sentry_envelope.c

@@ -136,6 +136,8 @@ envelope_item_get_ratelimiter_category(const sentry_envelope_item_t *item)
         return SENTRY_RL_CATEGORY_SESSION;
     } else if (sentry__string_eq(ty, "transaction")) {
         return SENTRY_RL_CATEGORY_TRANSACTION;
+    } else if (sentry__string_eq(ty, "replay_video")) {
+        return SENTRY_RL_CATEGORY_REPLAY;
     } else if (sentry__string_eq(ty, "client_report")) {
         // internal telemetry, bypass rate limiting
         return -1;
@@ -160,6 +162,8 @@ item_type_to_data_category(const char *ty)
         return SENTRY_DATA_CATEGORY_FEEDBACK;
     } else if (sentry__string_eq(ty, "trace_metric")) {
         return SENTRY_DATA_CATEGORY_TRACE_METRIC;
+    } else if (sentry__string_eq(ty, "replay_video")) {
+        return SENTRY_DATA_CATEGORY_REPLAY;
     }
     return SENTRY_DATA_CATEGORY_ERROR;
 }
@@ -1347,6 +1351,8 @@ data_category_to_string(sentry_data_category_t category)
         return "feedback";
     case SENTRY_DATA_CATEGORY_TRACE_METRIC:
         return "trace_metric";
+    case SENTRY_DATA_CATEGORY_REPLAY:
+        return "replay";
     case SENTRY_DATA_CATEGORY_MAX:
     default:
         return "unknown";

src/sentry_ratelimiter.c

@@ -3,7 +3,7 @@
 #include "sentry_slice.h"
 #include "sentry_utils.h"
 
-#define MAX_RATE_LIMITS 4
+#define MAX_RATE_LIMITS 5
 #define MAX_RETRY_AFTER (24 * 60 * 60) // 24h
 
 struct sentry_rate_limiter_s {
@@ -28,6 +28,7 @@ sentry__rate_limiter_new(void)
         rl->disabled_until[SENTRY_RL_CATEGORY_ERROR] = 0;
         rl->disabled_until[SENTRY_RL_CATEGORY_SESSION] = 0;
         rl->disabled_until[SENTRY_RL_CATEGORY_TRANSACTION] = 0;
+        rl->disabled_until[SENTRY_RL_CATEGORY_REPLAY] = 0;
     }
     return rl;
 }
@@ -64,6 +65,8 @@ sentry__rate_limiter_update_from_header(
             } else if (sentry__slice_eqs(category, "transaction")) {
                 rl->disabled_until[SENTRY_RL_CATEGORY_TRANSACTION]
                     = retry_after;
+            } else if (sentry__slice_eqs(category, "replay")) {
+                rl->disabled_until[SENTRY_RL_CATEGORY_REPLAY] = retry_after;
             }
 
             categories = sentry__slice_advance(categories, category.len);

src/sentry_ratelimiter.h

@@ -7,6 +7,7 @@
 #define SENTRY_RL_CATEGORY_ERROR 1
 #define SENTRY_RL_CATEGORY_SESSION 2
 #define SENTRY_RL_CATEGORY_TRANSACTION 3
+#define SENTRY_RL_CATEGORY_REPLAY 4
 
 typedef struct sentry_rate_limiter_s sentry_rate_limiter_t;
 

src/sentry_session_replay.h

@@ -24,4 +24,29 @@ bool sentry__session_replay_capture(
  */
 sentry_path_t *sentry__session_replay_get_path(const sentry_options_t *options);
 
+/**
+ * Returns whether the embedder's `<database>/replays/` staging directory holds
+ * a replay clip, so callers can skip crash-event work when nothing is staged.
+ */
+bool sentry__session_replay_has_pending(const sentry_options_t *options);
+
+/**
+ * Build and send the session-replay envelope for the crash described by
+ * `scope_source`. The replay is identified by the crash event's
+ * `contexts.replay.replay_id` and staged by the embedder as
+ * `<database>/replays/replay-<id>.{json,mp4}`.
+ *
+ * Native-daemon-only: called out-of-process by the crash
+ * daemon, so it runs only on a crash and delivers same-session. The sidecar and
+ * mp4 are consumed once and removed after the flush attempt, regardless of
+ * whether the envelope was built or sent, so a failed flush is not retried.
+ *
+ * `scope_source` is the crash event (`<run>/__sentry-event`); its scope fields
+ * and trace id are copied onto the replay, and its timestamp ends the replay
+ * window. If it is NULL or carries no `contexts.replay.replay_id`, nothing is
+ * flushed.
+ */
+void sentry__session_replay_flush_pending(const sentry_options_t *options,
+    sentry_transport_t *transport, sentry_value_t scope_source);
+
 #endif