feat: Sentry native crash backend

.github/workflows/e2e-test.yml

@@ -0,0 +1,64 @@
+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:
+        include:
+          - os: ubuntu-latest
+            cmake_generator: "Unix Makefiles"
+          - os: windows-latest
+            cmake_generator: "Visual Studio 17 2022"
+          - os: macos-latest
+            cmake_generator: "Unix Makefiles"
+
+    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**:
+
+- 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. ([#1433](https://github.com/getsentry/sentry-native/pull/1433))
+
 **Fixes**:
 
 - Crashpad: namespace mpack to avoid ODR violation. ([#1476](https://github.com/getsentry/sentry-native/pull/1476), [crashpad#143](https://github.com/getsentry/crashpad/pull/143))

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)")
 
@@ -219,9 +224,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")
@@ -230,14 +238,16 @@ 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")
+	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 +739,97 @@ 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 plus daemon-specific files
+	add_executable(sentry-crash
+		${SENTRY_SOURCES}
+		src/backends/native/sentry_crash_daemon.c
+		src/backends/native/sentry_crash_ipc.c
+		src/backends/native/sentry_crash_context.h
+	)
+
+	# Define standalone mode and copy compile definitions from sentry
+	target_compile_definitions(sentry-crash PRIVATE
+		SENTRY_CRASH_DAEMON_STANDALONE
+		SENTRY_BUILD_STATIC
+		SENTRY_HANDLER_STACK_SIZE=${SENTRY_HANDLER_STACK_SIZE}
+	)
+
+	# Windows-specific compile definitions
+	if(WIN32)
+		target_compile_definitions(sentry-crash PRIVATE
+			SENTRY_THREAD_STACK_GUARANTEE_FACTOR=${SENTRY_THREAD_STACK_GUARANTEE_FACTOR}
+		)
+	endif()
+
+	# 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)
+		target_include_directories(sentry-crash PRIVATE ${LIBUNWIND_INCLUDE_DIR})
+		target_link_libraries(sentry-crash PRIVATE ${LIBUNWIND_LIBRARIES})
+	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")

examples/example.c

@@ -221,6 +221,17 @@ has_arg(int argc, char **argv, const char *arg)
     return false;
 }
 
+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__)
 
@@ -279,10 +290,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
@@ -504,10 +530,41 @@ main(int argc, char **argv)
         sentry_options_set_logs_with_attributes(options, true);
     }
 
+    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;
     }
 
+    // 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(