feat: Sentry native crash backend

.github/workflows/e2e-test.yml

@@ -0,0 +1,58 @@
+name: E2E Integration Tests
+
+on:
+  push:
+    branches:
+      - master
+      - "release/**"
+  pull_request:
+
+concurrency:
+  group: e2e-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  e2e-test:
+    name: E2E Test (${{ matrix.os }})
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install dependencies (Linux)
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt update
+          sudo apt install -y cmake libcurl4-openssl-dev
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install test dependencies
+        run: pip install -r tests/requirements.txt
+
+      - name: Add hosts entry (Linux/macOS)
+        if: runner.os != 'Windows'
+        run: sudo sh -c 'echo "127.0.0.1 sentry.native.test" >> /etc/hosts'
+
+      - name: Add hosts entry (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: Add-Content C:\Windows\System32\drivers\etc\hosts "127.0.0.1 sentry.native.test"
+
+      - name: Run E2E tests
+        env:
+          SENTRY_E2E_DSN: ${{ secrets.SENTRY_E2E_DSN }}
+          SENTRY_E2E_AUTH_TOKEN: ${{ secrets.SENTRY_E2E_AUTH_TOKEN }}
+          SENTRY_E2E_ORG: ${{ secrets.SENTRY_E2E_ORG }}
+          SENTRY_E2E_PROJECT: ${{ secrets.SENTRY_E2E_PROJECT }}
+        run: pytest --capture=no --verbose tests/test_e2e_sentry.py

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+**Features**:
+
+- **Experimental**: Add new `native` crash handling backend as an alternative to `crashpad`, `breakpad`, and `inproc`. This backend uses an out-of-process daemon that monitors the application for crashes, generates minidumps, and sends crash reports to Sentry. It supports Linux, macOS, and Windows, and is fully compatible with TSAN and ASAN sanitizers. This feature is experimental and under active development. ([#1433](https://github.com/getsentry/sentry-native/pull/1433))
+
 **Fixes**:
 
 - Allow null custom log attributes without debug warning ([#1552](https://github.com/getsentry/sentry-native/pull/1552))

CMakeLists.txt

@@ -9,6 +9,11 @@ else()
 	cmake_policy(SET CMP0077 NEW)
 endif()
 
+# Allow target_link_libraries() in subdirectories
+if(POLICY CMP0079)
+	cmake_policy(SET CMP0079 NEW)
+endif()
+
 # Allow downstream SDKs to override the SDK version at CMake configuration time
 set(SENTRY_SDK_VERSION "" CACHE STRING "Override the SDK version (supports full semver format with build metadata)")
 
@@ -211,9 +216,12 @@ else()
 	set(SENTRY_DEFAULT_BACKEND "inproc")
 endif()
 
+# Native backend is available on all platforms as an alternative
+# It's lightweight (~5K LOC) and supports all platforms
+
 if(NOT DEFINED SENTRY_BACKEND)
 	set(SENTRY_BACKEND ${SENTRY_DEFAULT_BACKEND} CACHE STRING
-		"The sentry backend responsible for reporting crashes, can be either 'none', 'inproc', 'breakpad' or 'crashpad'.")
+		"The sentry backend responsible for reporting crashes, can be either 'none', 'inproc', 'breakpad', 'crashpad', or 'native'.")
 endif()
 
 if(SENTRY_BACKEND STREQUAL "crashpad")
@@ -222,14 +230,18 @@ elseif(SENTRY_BACKEND STREQUAL "inproc")
 	set(SENTRY_BACKEND_INPROC TRUE)
 elseif(SENTRY_BACKEND STREQUAL "breakpad")
 	set(SENTRY_BACKEND_BREAKPAD TRUE)
+elseif(SENTRY_BACKEND STREQUAL "native")
+	message(WARNING "The 'native' backend is experimental and under active development. "
+		"It may have incomplete features or unexpected behavior.")
+	set(SENTRY_BACKEND_NATIVE TRUE)
 elseif(SENTRY_BACKEND STREQUAL "none")
 	set(SENTRY_BACKEND_NONE TRUE)
 elseif(SENTRY_BACKEND STREQUAL "custom")
 	message(DEBUG
 		"SENTRY_BACKEND set to 'custom' - a custom backend source must be added to the compilation unit by the downstream SDK.")
 else()
 	message(FATAL_ERROR
-		"SENTRY_BACKEND must be one of 'crashpad', 'inproc', 'breakpad' or 'none'.
+		"SENTRY_BACKEND must be one of 'crashpad', 'inproc', 'breakpad', 'native', or 'none'.
 		Downstream SDKs may choose to provide their own by specifying 'custom'.")
 endif()
 
@@ -729,6 +741,96 @@ elseif(SENTRY_BACKEND_BREAKPAD)
 	endif()
 elseif(SENTRY_BACKEND_INPROC)
 	target_compile_definitions(sentry PRIVATE SENTRY_WITH_INPROC_BACKEND)
+elseif(SENTRY_BACKEND_NATIVE)
+	target_compile_definitions(sentry PRIVATE SENTRY_WITH_NATIVE_BACKEND)
+
+	# Native backend sources and configuration are in src/CMakeLists.txt
+	# The native backend requires C11 for atomics (set in src/CMakeLists.txt)
+
+	# Build sentry-crash executable for native backend
+	# Get all sources that were added to sentry target
+	get_target_property(SENTRY_SOURCES sentry SOURCES)
+
+	# Create daemon executable with same sources (already includes
+	# sentry_crash_daemon.c and sentry_crash_ipc.c from src/CMakeLists.txt)
+	add_executable(sentry-crash
+		${SENTRY_SOURCES}
+	)
+
+	# Copy all compile definitions from sentry target so shared sources
+	# compile under identical preprocessor conditions (backend, transport,
+	# unwinder, compression, etc.)
+	get_target_property(SENTRY_COMPILE_DEFS sentry COMPILE_DEFINITIONS)
+	if(SENTRY_COMPILE_DEFS)
+		# The daemon is always a static executable, never a shared library
+		list(REMOVE_ITEM SENTRY_COMPILE_DEFS "SENTRY_BUILD_SHARED")
+		target_compile_definitions(sentry-crash PRIVATE ${SENTRY_COMPILE_DEFS})
+	endif()
+
+	# Add daemon-specific definitions
+	target_compile_definitions(sentry-crash PRIVATE
+		SENTRY_CRASH_DAEMON_STANDALONE
+		SENTRY_BUILD_STATIC
+	)
+
+	# Copy include directories from sentry target
+	target_include_directories(sentry-crash PRIVATE
+		${PROJECT_SOURCE_DIR}/include
+		${PROJECT_SOURCE_DIR}/src
+		${PROJECT_SOURCE_DIR}/src/backends/native
+	)
+
+	# Link same libraries as sentry
+	if(WIN32)
+		target_link_libraries(sentry-crash PRIVATE dbghelp shlwapi version)
+	elseif(LINUX OR ANDROID)
+		target_link_libraries(sentry-crash PRIVATE pthread rt dl)
+	elseif(APPLE)
+		find_library(COREFOUNDATION_LIBRARY CoreFoundation REQUIRED)
+		find_library(SECURITY_LIBRARY Security REQUIRED)
+		target_link_libraries(sentry-crash PRIVATE
+			${COREFOUNDATION_LIBRARY}
+			${SECURITY_LIBRARY}
+		)
+	endif()
+
+	# Transport-specific libraries
+	if(SENTRY_TRANSPORT_CURL)
+		target_link_libraries(sentry-crash PRIVATE CURL::libcurl)
+	endif()
+
+	if(SENTRY_TRANSPORT_WINHTTP)
+		target_link_libraries(sentry-crash PRIVATE winhttp)
+	endif()
+
+
+	# Compression library
+	if(SENTRY_TRANSPORT_COMPRESSION)
+		target_link_libraries(sentry-crash PRIVATE ZLIB::ZLIB)
+	endif()
+
+	# Unwinder libraries (must match sentry target)
+	if(SENTRY_WITH_LIBUNWINDSTACK)
+		target_link_libraries(sentry-crash PRIVATE unwindstack)
+	endif()
+
+	if(SENTRY_WITH_LIBUNWIND AND LINUX)
+		target_link_libraries(sentry-crash PRIVATE unwind)
+	endif()
+
+	# Make sentry library depend on crash daemon so it's always built together
+	add_dependencies(sentry sentry-crash)
+
+	# Install daemon
+	install(TARGETS sentry-crash
+		RUNTIME DESTINATION bin
+	)
+
+	if(DEFINED SENTRY_FOLDER)
+		# Native backend doesn't have separate targets to organize
+	endif()
+
+	message(STATUS "Sentry crash daemon executable: enabled")
 endif()
 
 option(SENTRY_INTEGRATION_QT "Build Qt integration")

README.md

@@ -247,6 +247,10 @@ using `cmake -D BUILD_SHARED_LIBS=OFF ..`.
     only supported on Desktop OSs.
   - **inproc**: A small in-process handler that is supported on all platforms,
     and is used as a default on Android.
+  - **native**: **(Experimental)** An out-of-process crash handler that uses a
+    lightweight daemon to monitor the application, generate minidumps, and send
+    crash reports. Supports Linux, macOS, and Windows. Compatible with TSAN and
+    ASAN sanitizers. This backend is under active development.
   - **none**: This builds `sentry-native` without a backend, so it does not handle
     crashes. It is primarily used for tests.
 

examples/example.c

@@ -284,6 +284,17 @@ make_proxy_url(char *buf, size_t buf_size, const char *scheme,
     }
 }
 
+static const char *
+get_arg_value(int argc, char **argv, const char *arg)
+{
+    for (int i = 1; i < argc - 1; i++) {
+        if (strcmp(argv[i], arg) == 0) {
+            return argv[i + 1];
+        }
+    }
+    return NULL;
+}
+
 #if defined(SENTRY_PLATFORM_WINDOWS) && !defined(__MINGW32__)                  \
     && !defined(__MINGW64__)
 
@@ -342,10 +353,25 @@ static void *invalid_mem = (void *)0xFFFFFFFFFFFFFF9B; // -100 for memset
 static void *invalid_mem = (void *)1;
 #endif
 
+// Detect Address Sanitizer (works for both GCC and Clang)
+#if defined(__SANITIZE_ADDRESS__)
+#    define SENTRY_ASAN_ACTIVE 1
+#elif defined(__has_feature)
+#    if __has_feature(address_sanitizer)
+#        define SENTRY_ASAN_ACTIVE 1
+#    endif
+#endif
+
 static void
 trigger_crash()
 {
+#ifdef SENTRY_ASAN_ACTIVE
+    // Under ASAN, raise signal directly to bypass ASAN's memory interception.
+    // ASAN intercepts memset and would abort before our signal handler runs.
+    raise(SIGSEGV);
+#else
     memset((char *)invalid_mem, 1, 100);
+#endif
 }
 
 static void
@@ -658,6 +684,29 @@ main(int argc, char **argv)
             options, discarding_before_breadcrumb_callback, NULL);
     }
 
+    if (has_arg(argc, argv, "crash-mode")) {
+        const char *mode = get_arg_value(argc, argv, "crash-mode");
+        if (mode != NULL) {
+            if (strcmp(mode, "minidump") == 0) {
+                sentry_options_set_crash_reporting_mode(
+                    options, SENTRY_CRASH_REPORTING_MODE_MINIDUMP);
+            } else if (strcmp(mode, "native") == 0) {
+                sentry_options_set_crash_reporting_mode(
+                    options, SENTRY_CRASH_REPORTING_MODE_NATIVE);
+            } else if (strcmp(mode, "native-with-minidump") == 0) {
+                sentry_options_set_crash_reporting_mode(
+                    options, SENTRY_CRASH_REPORTING_MODE_NATIVE_WITH_MINIDUMP);
+            }
+        }
+    }
+
+    // E2E test mode: generate unique test ID for event correlation
+    char e2e_test_id[37] = { 0 };
+    if (has_arg(argc, argv, "e2e-test")) {
+        sentry_uuid_t test_uuid = sentry_uuid_new_v4();
+        sentry_uuid_as_string(&test_uuid, e2e_test_id);
+    }
+
     if (0 != sentry_init(options)) {
         return EXIT_FAILURE;
     }
@@ -683,6 +732,14 @@ main(int argc, char **argv)
                 sentry_value_new_string("my_global_value"), NULL));
     }
 
+    // E2E test mode: set tags and output test ID for event correlation
+    if (e2e_test_id[0] != '\0') {
+        sentry_set_tag("test.id", e2e_test_id);
+        sentry_set_tag("test.suite", "e2e");
+        printf("TEST_ID:%s\n", e2e_test_id);
+        fflush(stdout);
+    }
+
     if (has_arg(argc, argv, "log-attributes")) {
         sentry_value_t attributes = sentry_value_new_object();
         sentry_value_t attr = sentry_value_new_attribute(