feat: Implement the GPU Info gathering within the Native SDK

.github/workflows/ci.yml

@@ -251,7 +251,7 @@ jobs:
         run: |
           sudo apt update
           # Install common dependencies
-          sudo apt install cmake llvm valgrind zlib1g-dev libcurl4-openssl-dev
+          sudo apt install cmake llvm valgrind zlib1g-dev libcurl4-openssl-dev libvulkan-dev
           # For GCC, install both gcc-X and g++-X. For Clang, only install clang-X (includes C++ compiler)
           if [[ "$CC" == gcc-* ]]; then
             sudo apt install "${CC}" "${CXX}"

.gitmodules

@@ -14,3 +14,6 @@
 [submodule "external/benchmark"]
 	path = external/benchmark
 	url = https://github.com/google/benchmark.git
+[submodule "external/vulkan-headers"]
+	path = external/vulkan-headers
+	url = https://github.com/KhronosGroup/Vulkan-Headers.git

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased:
 
+**Features**:
+
+- Implement GPU info context gathering for the Native SDK. Supported on Windows, macOS, and Linux via Vulkan. Disabled by default — enable with `-DSENTRY_WITH_GPU_INFO=ON`. ([#1336](https://github.com/getsentry/sentry-native/pull/1336))
+
 **Fixes**:
 
 - inproc: only the handling thread cleans up after the crash. ([#1579](https://github.com/getsentry/sentry-native/pull/1579))

CMakeLists.txt

@@ -103,6 +103,13 @@ option(SENTRY_PIC "Build sentry (and dependent) libraries as position independen
 
 option(SENTRY_TRANSPORT_COMPRESSION "Enable transport gzip compression" OFF)
 
+option(SENTRY_WITH_GPU_INFO "Build with GPU information gathering support (supported on Windows, macOS, Linux)" OFF)
+
+# GPU info enabled - no longer requires Vulkan SDK (uses headers submodule + dynamic linking)
+if(SENTRY_WITH_GPU_INFO)
+	message(STATUS "GPU information gathering enabled (using vulkan-headers submodule)")
+endif()
+
 option(SENTRY_BUILD_TESTS "Build sentry-native tests" "${SENTRY_MAIN_PROJECT}")
 option(SENTRY_BUILD_EXAMPLES "Build sentry-native example(s)" "${SENTRY_MAIN_PROJECT}")
 option(SENTRY_BUILD_BENCHMARKS "Build sentry-native benchmarks" OFF)
@@ -605,6 +612,12 @@ if(NOT XBOX)
 	endif()
 endif()
 
+# handle Vulkan headers for GPU info  
+if(SENTRY_WITH_GPU_INFO)
+	target_include_directories(sentry PRIVATE 
+		"$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/external/vulkan-headers/include>")
+endif()
+
 # apply platform libraries to sentry library
 target_link_libraries(sentry PRIVATE ${_SENTRY_PLATFORM_LIBS})
 

CONTRIBUTING.md

@@ -184,7 +184,7 @@ The example currently supports the following commands:
 - `discarding-before-transaction`: Installs a `before_transaction()` callback that discards the transaction.
 - `traces-sampler`: Installs a traces sampler callback function when used alongside `capture-transaction`.
 - `attach-view-hierarchy`: Adds a `view-hierarchy.json` attachment file, giving it the proper `attachment_type` and `content_type`.
- This file can be found in `./tests/fixtures/view-hierachy.json`.
+  This file can be found in `./tests/fixtures/view-hierachy.json`.
 - `set-trace`: Sets the scope `propagation_context`'s trace data to the given `trace_id="aaaabbbbccccddddeeeeffff00001111"` and `parent_span_id=""f0f0f0f0f0f0f0f0"`.
 - `capture-with-scope`: Captures an event with a local scope.
 - `attach-to-scope`: Same as `attachment` but attaches the file to the local scope.
@@ -196,6 +196,7 @@ The example currently supports the following commands:
 - `test-logger-before-crash`: Outputs marker directly using printf for test parsing before crash.
 
 Only on Linux using crashpad:
+
 - `crashpad-wait-for-upload`: Couples application shutdown to complete the upload in the `crashpad_handler`.
 
 Only on Windows using crashpad with its WER handler module:
@@ -218,15 +219,15 @@ invoked directly.
 
 ## Handling locks
 
-There are a couple of rules based on the current usage of mutexes in the Native SDK that should always be 
+There are a couple of rules based on the current usage of mutexes in the Native SDK that should always be
 applied in order not to have to fight boring concurrency bugs:
 
 * we use recursive mutexes throughout the code-base
 * these primarily allow us to call public interfaces from internal code instead of having a layer in-between
-* but they come at the risk of less clarity whether a lock release still leaves a live lock 
+* but they come at the risk of less clarity whether a lock release still leaves a live lock
 * they should not be considered as convenience:
   * reduce the amount of recursive locking to an absolute minimum
-  * instead of retrieval via global locks, pass shared state like `options` or `scope` around in internal helpers 
+  * instead of retrieval via global locks, pass shared state like `options` or `scope` around in internal helpers
   * or better yet: extract what you need into locals, then release the lock early
 * we provide lexical scope macros `SENTRY_WITH_OPTIONS` and `SENTRY_WITH_SCOPE` (and variants) as convenience wrappers
 * if you use them be aware of the following:
@@ -236,3 +237,7 @@ applied in order not to have to fight boring concurrency bugs:
   * never early-return or jump (via `goto` or `return`) from within a `SENTRY_WITH_*` block: doing so skips the corresponding release or cleanup
   * in particular, since `options` are readonly after `sentry_init()` the lock is only acquired to increment the refcount for the duration of `SENTRY_WITH_OPTIONS`
   * however, `SENTRY_WITH_SCOPE` (and variants) always hold the lock for the entirety of their lexical scope
+
+## Runtime Library Requirements
+
+**Vulkan** (optional): When GPU info gathering is enabled (`-DSENTRY_WITH_GPU_INFO=ON`), a Vulkan runtime library (e.g. `libvulkan.so`, `vulkan-1.dll`, or `libvulkan.dylib` via MoltenVK) must be available at runtime. The SDK dynamically loads the library — no Vulkan SDK is needed at build time (headers are vendored). If the library is not found at runtime, GPU info is silently skipped.

README.md

@@ -1,4 +1,5 @@
 [![Conan Center](https://shields.io/conan/v/sentry-native)](https://conan.io/center/recipes/sentry-native) [![homebrew](https://img.shields.io/homebrew/v/sentry-native)](https://formulae.brew.sh/formula/sentry-native) [![nixpkgs unstable](https://repology.org/badge/version-for-repo/nix_unstable/sentry-native.svg)](https://github.com/NixOS/nixpkgs/blob/nixos-unstable/pkgs/by-name/se/sentry-native/package.nix) [![vcpkg](https://shields.io/vcpkg/v/sentry-native)](https://vcpkg.link/ports/sentry-native)
+
 <p align="center">
   <a href="https://sentry.io/?utm_source=github&utm_medium=logo" target="_blank">
     <picture>
@@ -10,6 +11,7 @@
 </p>
 
 # Official Sentry SDK for C/C++ <!-- omit in toc -->
+
 [![GH Workflow](https://img.shields.io/github/actions/workflow/status/getsentry/sentry-native/ci.yml?branch=master)](https://github.com/getsentry/sentry-native/actions)
 [![codecov](https://codecov.io/gh/getsentry/sentry-native/branch/master/graph/badge.svg)](https://codecov.io/gh/getsentry/sentry-native)
 
@@ -184,8 +186,8 @@ specifying the `SDKROOT`:
 $ export SDKROOT=$(xcrun --sdk macosx --show-sdk-path)
 ```
 
-If you build on macOS using _CMake 4_, then you _must_ specify the `SDKROOT`, because 
-[CMake 4 defaults to an empty `CMAKE_OSX_SYSROOT`](https://cmake.org/cmake/help/latest/variable/CMAKE_OSX_SYSROOT.html), 
+If you build on macOS using _CMake 4_, then you _must_ specify the `SDKROOT`, because
+[CMake 4 defaults to an empty `CMAKE_OSX_SYSROOT`](https://cmake.org/cmake/help/latest/variable/CMAKE_OSX_SYSROOT.html),
 which could lead to inconsistent include paths when CMake tries to gather the `sysroot` later in the build.
 
 ### Compile-Time Options
@@ -301,6 +303,11 @@ using `cmake -D BUILD_SHARED_LIBS=OFF ..`.
   tuning the thread stack guarantee parameters. Warnings and errors in the process of setting thread stack guarantees
   will always be logged.
 
+- `SENTRY_WITH_GPU_INFO` (Default: `OFF`):
+  Enables GPU information collection and reporting. Supported on Windows, macOS, and Linux. When enabled, the SDK
+  will attempt to gather GPU details such as GPU name, vendor, memory size, and driver version, which are included
+  in event contexts. The implementation uses the Vulkan API with dynamic loading for cross-platform GPU detection.
+
 ### Support Matrix
 
 | Feature    | Windows | macOS | Linux | Android | iOS  |

external/CMakeLists.txt

@@ -197,3 +197,4 @@ target_include_directories(breakpad_client
 	PUBLIC
 	"$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>"
 )
+

src/CMakeLists.txt

@@ -272,3 +272,30 @@ else()
 		screenshot/sentry_screenshot_none.c
 	)
 endif()
+
+# gpu
+if(SENTRY_WITH_GPU_INFO)
+	target_compile_definitions(sentry PRIVATE SENTRY_WITH_GPU_INFO)
+	sentry_target_sources_cwd(sentry
+		sentry_gpu.h
+		gpu/sentry_gpu_common.c
+	)
+
+	if(WIN32 OR (APPLE AND NOT IOS) OR LINUX)
+		sentry_target_sources_cwd(sentry
+			gpu/sentry_gpu_vulkan.h
+			gpu/sentry_gpu_vulkan.c
+		)
+	else()
+		# For platforms that do not support GPU info gathering, we provide a no-op implementation
+		sentry_target_sources_cwd(sentry
+			gpu/sentry_gpu_none.c
+		)
+	endif()
+else()
+	sentry_target_sources_cwd(sentry
+		sentry_gpu.h
+		gpu/sentry_gpu_common.c
+		gpu/sentry_gpu_none.c
+	)
+endif()

src/gpu/sentry_gpu_common.c

@@ -0,0 +1,169 @@
+#include "sentry_gpu.h"
+#include "sentry_logger.h"
+#include "sentry_string.h"
+
+char *
+sentry__gpu_vendor_id_to_name(unsigned int vendor_id)
+{
+    switch (vendor_id) {
+    case 0x10DE:
+        return sentry__string_clone("NVIDIA Corporation");
+    case 0x1002:
+    case 0x1022:
+        return sentry__string_clone("Advanced Micro Devices, Inc. [AMD/ATI]");
+    case 0x8086:
+        return sentry__string_clone("Intel Corporation");
+    case 0x106B:
+        return sentry__string_clone("Apple Inc.");
+    case 0x1414:
+        return sentry__string_clone("Microsoft Corporation");
+    case 0x5143:
+    case 0x17CB:
+        return sentry__string_clone("Qualcomm");
+    case 0x13B5:
+        return sentry__string_clone("ARM");
+    case 0x144D:
+        return sentry__string_clone("Samsung Electronics");
+    case 0x1AE0:
+        return sentry__string_clone("Google");
+    case 0x1010:
+        return sentry__string_clone("VideoLogic");
+    case 0x1023:
+        return sentry__string_clone("Trident Microsystems");
+    case 0x102B:
+        return sentry__string_clone("Matrox Graphics");
+    case 0x121A:
+        return sentry__string_clone("3dfx Interactive");
+    case 0x18CA:
+        return sentry__string_clone("XGI Technology");
+    case 0x1039:
+        return sentry__string_clone("Silicon Integrated Systems [SiS]");
+    case 0x126F:
+        return sentry__string_clone("Silicon Motion");
+    default: {
+        char unknown_vendor[64];
+        snprintf(unknown_vendor, sizeof(unknown_vendor), "Unknown (0x%04X)",
+            vendor_id);
+        return sentry__string_clone(unknown_vendor);
+    }
+    }
+}
+
+static sentry_value_t
+create_gpu_context_from_info(sentry_gpu_info_t *gpu_info)
+{
+    if (!gpu_info) {
+        SENTRY_WARN("No GPU info provided. Skipping GPU context creation.");
+        return sentry_value_new_null();
+    }
+
+    sentry_value_t gpu_context = sentry_value_new_object();
+    if (sentry_value_is_null(gpu_context)) {
+        return gpu_context;
+    }
+
+    // Add type field for frontend recognition
+    sentry_value_set_by_key(
+        gpu_context, "type", sentry_value_new_string("gpu"));
+
+    // Add GPU name
+    if (gpu_info->name) {
+        sentry_value_set_by_key(
+            gpu_context, "name", sentry_value_new_string(gpu_info->name));
+    }
+
+    // Add vendor information
+    if (gpu_info->vendor_name) {
+        sentry_value_set_by_key(gpu_context, "vendor_name",
+            sentry_value_new_string(gpu_info->vendor_name));
+    }
+
+    if (gpu_info->vendor_id != 0) {
+        char vendor_id_str[32];
+        snprintf(
+            vendor_id_str, sizeof(vendor_id_str), "%u", gpu_info->vendor_id);
+        sentry_value_set_by_key(
+            gpu_context, "vendor_id", sentry_value_new_string(vendor_id_str));
+    }
+
+    // Add device ID
+    if (gpu_info->device_id != 0) {
+        char device_id_str[32];
+        snprintf(
+            device_id_str, sizeof(device_id_str), "%u", gpu_info->device_id);
+        sentry_value_set_by_key(
+            gpu_context, "device_id", sentry_value_new_string(device_id_str));
+    }
+
+    // Add memory size
+    if (gpu_info->memory_size > 0) {
+        sentry_value_set_by_key(gpu_context, "memory_size",
+            sentry_value_new_uint64(gpu_info->memory_size));
+    }
+
+    // Add driver version
+    if (gpu_info->driver_version) {
+        sentry_value_set_by_key(gpu_context, "driver_version",
+            sentry_value_new_string(gpu_info->driver_version));
+    }
+
+    sentry_value_freeze(gpu_context);
+    return gpu_context;
+}
+
+void
+sentry__free_gpu_info(sentry_gpu_info_t *gpu_info)
+{
+    if (!gpu_info) {
+        return;
+    }
+
+    sentry_free(gpu_info->name);
+    sentry_free(gpu_info->vendor_name);
+    sentry_free(gpu_info->driver_version);
+    sentry_free(gpu_info);
+}
+
+void
+sentry__free_gpu_list(sentry_gpu_list_t *gpu_list)
+{
+    if (!gpu_list) {
+        return;
+    }
+
+    for (unsigned int i = 0; i < gpu_list->count; i++) {
+        sentry__free_gpu_info(gpu_list->gpus[i]);
+    }
+
+    sentry_free(gpu_list->gpus);
+    sentry_free(gpu_list);
+}
+
+void
+sentry__add_gpu_contexts(sentry_value_t contexts)
+{
+    sentry_gpu_list_t *gpu_list = sentry__get_gpu_info();
+    if (!gpu_list) {
+        return;
+    }
+
+    unsigned int context_index = 0;
+    for (unsigned int i = 0; i < gpu_list->count; i++) {
+        sentry_value_t gpu_context
+            = create_gpu_context_from_info(gpu_list->gpus[i]);
+        if (!sentry_value_is_null(gpu_context)) {
+            // Use context_index (not i) so keys are contiguous: gpu, gpu2, gpu3
+            char context_key[32];
+            if (context_index == 0) {
+                snprintf(context_key, sizeof(context_key), "gpu");
+            } else {
+                snprintf(context_key, sizeof(context_key), "gpu%u",
+                    context_index + 1);
+            }
+            sentry_value_set_by_key(contexts, context_key, gpu_context);
+            context_index++;
+        }
+    }
+
+    sentry__free_gpu_list(gpu_list);
+}

src/gpu/sentry_gpu_none.c

@@ -0,0 +1,7 @@
+#include "sentry_gpu.h"
+
+sentry_gpu_list_t *
+sentry__get_gpu_info(void)
+{
+    return NULL;
+}