Crash tracking

build/cmake/FindLibdatadog.cmake

@@ -1,21 +1,21 @@
 include(FetchContent)
 
-set(LIBDATADOG_VERSION "v8.0.0" CACHE STRING "libdatadog version")
+set(LIBDATADOG_VERSION "v9.0.0" CACHE STRING "libdatadog version")
 
 if (CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64 OR CMAKE_SYSTEM_PROCESSOR STREQUAL arm64)
     if (DEFINED ENV{IsAlpine} AND "$ENV{IsAlpine}" MATCHES "true")
-        set(SHA256_LIBDATADOG "09640a86f6beb5069c25ff7772f8b1a336d68f33dd94469711be9b98388fee0b" CACHE STRING "libdatadog sha256")
+        set(SHA256_LIBDATADOG "c2c6c32f612e8c1682131e72bd50492d809bac973f516e56e163e797435eef75" CACHE STRING "libdatadog sha256")
         set(FILE_TO_DOWNLOAD libdatadog-aarch64-alpine-linux-musl.tar.gz)
     else()
-        set(SHA256_LIBDATADOG "ff3c3f4650ac45d5700917026a84953b1d52c07652b834a12ada2f80c4cda47e" CACHE STRING "libdatadog sha256")
+        set(SHA256_LIBDATADOG "97c4fc46f92580b8929e8fcc3f51b47226836e29bce0b57ac8d3387a27a81ce1" CACHE STRING "libdatadog sha256")
         set(FILE_TO_DOWNLOAD libdatadog-aarch64-unknown-linux-gnu.tar.gz)
     endif()
 else()
     if (DEFINED ENV{IsAlpine} AND "$ENV{IsAlpine}" MATCHES "true")
-        set(SHA256_LIBDATADOG "17360251a8585450d8499ae5e323161a1486e487937b257571adc4c06a2a3688" CACHE STRING "libdatadog sha256")
+        set(SHA256_LIBDATADOG "68e67c5e87616f830289bc85626d2062277bef54694cc6dbb445105c66fe8885" CACHE STRING "libdatadog sha256")
         set(FILE_TO_DOWNLOAD libdatadog-${CMAKE_SYSTEM_PROCESSOR}-alpine-linux-musl.tar.gz)
     else()
-        set(SHA256_LIBDATADOG "1856e9b209f3a414536930eea1a8d4c854539ccfbf395ba1740f0d8f71bc2938" CACHE STRING "libdatadog sha256")
+        set(SHA256_LIBDATADOG "cd89cbe480db0b828a43afd161ddd83e57319dbe3d412fa4a2d096daae244595" CACHE STRING "libdatadog sha256")
         set(FILE_TO_DOWNLOAD libdatadog-${CMAKE_SYSTEM_PROCESSOR}-unknown-linux-gnu.tar.gz)
     endif()
 endif()

build/cmake/FindLibunwind.cmake

@@ -13,6 +13,9 @@ ExternalProject_Add(libunwind
     BUILD_ALWAYS false
     BUILD_BYPRODUCTS ${LIBUNWIND_BINARY_DIR}/src/.libs/libunwind-${CMAKE_SYSTEM_PROCESSOR}.a
                      ${LIBUNWIND_BINARY_DIR}/src/.libs/libunwind.a
+                     ${LIBUNWIND_BINARY_DIR}/src/.libs/libunwind-ptrace.a
+                     ${LIBUNWIND_BINARY_DIR}/src/.libs/libunwind-dwarf-common.a
+                     ${LIBUNWIND_BINARY_DIR}/src/.libs/libunwind-dwarf-generic.a
 )
 
 
@@ -26,6 +29,9 @@ target_include_directories(libunwind-lib INTERFACE
 target_link_libraries(libunwind-lib INTERFACE
     ${LIBUNWIND_BINARY_DIR}/src/.libs/libunwind-${CMAKE_SYSTEM_PROCESSOR}.a
     ${LIBUNWIND_BINARY_DIR}/src/.libs/libunwind.a
+    ${LIBUNWIND_BINARY_DIR}/src/.libs/libunwind-ptrace.a
+    ${LIBUNWIND_BINARY_DIR}/src/.libs/libunwind-dwarf-common.a
+    ${LIBUNWIND_BINARY_DIR}/src/.libs/libunwind-dwarf-generic.a
 )
 
 add_dependencies(libunwind-lib libunwind)

profiler/src/Demos/Samples.ExceptionGenerator/Program.cs

@@ -19,6 +19,7 @@ public enum Scenario
         GenericExceptions = 4,
         TimeItExceptions = 5,
         MeasureExceptions = 6,
+        Unhandled = 7
     }
 
     public class Program
@@ -90,6 +91,10 @@ public static void Main(string[] args)
                                     Console.WriteLine(" ########### Measuring exceptions...");
                                     break;
 
+                                case Scenario.Unhandled:
+                                    Console.WriteLine(" ########### Crashing...");
+                                    throw new InvalidOperationException("Task failed successfully.");
+
                                 default:
                                     Console.WriteLine($" ########### Unknown scenario: {scenario}.");
                                     break;

profiler/src/ProfilerEngine/Datadog.Linux.ApiWrapper/functions_to_wrap.c

@@ -4,6 +4,8 @@
 #include <signal.h>
 #include <stddef.h>
 #include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
 
 /* dl_iterate_phdr wrapper
 The .NET profiler on Linux uses a classic signal-based approach to collect thread callstack.
@@ -57,6 +59,49 @@ unsigned long long dd_inside_wrapped_functions()
     return functions_entered_counter;
 }
 
+__attribute__((constructor))
+void initLibrary(void) {
+    // If crashtracking is enabled, check the value of DOTNET_DbgEnableMiniDump
+    // If set, set DD_TRACE_CRASH_HANDLER_PASSTHROUGH to indicate dd-dotnet that it should call createdump
+    // If not set, set it to 1 so that .NET calls createdump in case of crash
+    // (and we will redirect the call to dd-dotnet)
+    char* crashHandler = getenv("DD_TRACE_CRASH_HANDLER");
+
+    if (crashHandler != NULL && crashHandler[0] != '\0')
+    {
+        char* enableMiniDump = getenv("DOTNET_DbgEnableMiniDump");
+
+        if (enableMiniDump == NULL)
+        {
+            enableMiniDump = getenv("COMPlus_DbgEnableMiniDump");
+        }
+
+        if (enableMiniDump != NULL && enableMiniDump[0] == '1')
+        {
+            // If DOTNET_DbgEnableMiniDump is set, the crash handler should call createdump when done
+            char* passthrough = getenv("DD_TRACE_CRASH_HANDLER_PASSTHROUGH");
+
+            if (passthrough == NULL || passthrough[0] == '\0')
+            {
+                // If passthrough is already set, don't override it
+                // This handles the case when, for example, the user calls dotnet run
+                //  - dotnet run sets DOTNET_DbgEnableMiniDump=1
+                //  - dotnet then launches the target app
+                //  - the target app thinks DOTNET_DbgEnableMiniDump has been set by the user and enables passthrough
+                setenv("DD_TRACE_CRASH_HANDLER_PASSTHROUGH", "1", 1);
+            }
+        }
+        else
+        {
+            // If DOTNET_DbgEnableMiniDump is not set, we set it so that the crash handler is called,
+            // but we instruct it to not call createdump afterwards
+            setenv("COMPlus_DbgEnableMiniDump", "1", 1);
+            setenv("DOTNET_DbgEnableMiniDump", "1", 1);
+            setenv("DD_TRACE_CRASH_HANDLER_PASSTHROUGH", "0", 1);
+        }
+    }
+}
+
 /* Function pointers to hold the value of the glibc functions */
 static int (*__real_dl_iterate_phdr)(int (*callback)(struct dl_phdr_info* info, size_t size, void* data), void* data) = NULL;
 
@@ -121,6 +166,90 @@ int dladdr(const void* addr_arg, Dl_info* info)
     return result;
 }
 
+/* Function pointers to hold the value of the glibc functions */
+static int (*__real_execve)(const char* pathname, char* const argv[], char* const envp[]) = NULL;
+
+static char* ddTracePath = NULL;
+
+int execve(const char* pathname, char* const argv[], char* const envp[])
+{
+    if (__real_execve == NULL)
+    {
+        __real_execve = dlsym(RTLD_NEXT, "execve");
+
+        ddTracePath = getenv("DD_TRACE_CRASH_HANDLER");
+
+        if (ddTracePath != NULL && ddTracePath[0] == '\0')
+        {
+            ddTracePath = NULL;
+        }
+    }
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wtautological-compare"
+    if (ddTracePath != NULL && pathname != NULL)
+    {
+        size_t length = strlen(pathname);
+
+        if (length >= 11 && strcmp(pathname + length - 11, "/createdump") == 0)
+        {
+            // Execute the alternative crash handler, and prepend "createdump" to the arguments
+
+            // Count the number of arguments (the list ends with a null pointer)
+            int argc = 0;
+            while (argv[argc++] != NULL);
+
+            // We add two arguments: the path to dd-dotnet, and "createdump"
+            char** newArgv = malloc((argc + 2) * sizeof(char*));
+
+            // By convention, argv[0] contains the name of the executable
+            // Insert createdump as the first actual argument
+            newArgv[0] = ddTracePath;
+            newArgv[1] = "createdump";
+
+            // Copy the remaining arguments
+            memcpy(newArgv + 2, argv, sizeof(char*) * argc);
+
+            size_t envp_count;
+            for (envp_count = 0; envp[envp_count]; ++envp_count);
+            char** new_envp = malloc((envp_count + 1) * sizeof(char*)); // +1 for NULL terminator
+
+            int index = 0;
+
+            for (size_t i = 0; i < envp_count; ++i) {
+                if (strncmp(envp[i], "LD_PRELOAD=", strlen("LD_PRELOAD=")) == 0) {
+                    continue;
+                }
+
+                if (strncmp(envp[i], "CORECLR_ENABLE_PROFILING=", strlen("CORECLR_ENABLE_PROFILING=")) == 0) {
+                    continue;
+                }
+
+                if (strncmp(envp[i], "DOTNET_DbgEnableMiniDump=", strlen("DOTNET_DbgEnableMiniDump=")) == 0) {
+                    continue;
+                }
+
+                if (strncmp(envp[i], "COMPlus_DbgEnableMiniDump=", strlen("COMPlus_DbgEnableMiniDump=")) == 0) {
+                    continue;
+                }
+
+                new_envp[index++] = envp[i];
+            }
+            new_envp[index] = NULL; // NULL terminate the array
+
+            int result = __real_execve(ddTracePath, newArgv, new_envp);
+
+            free(newArgv);
+            free(new_envp);
+
+            return result;
+        }
+    }
+#pragma clang diagnostic pop
+
+    return __real_execve(pathname, argv, envp);
+}
+
 #ifdef DD_ALPINE
 
 /* Function pointers to hold the value of the glibc functions */