Category specific runtime callback

Author: gyuheon0h

debug_runtime_callback.rb

@@ -0,0 +1,137 @@
+require 'json'
+require 'webrick'
+require 'fiddle'
+require 'datadog'
+
+# Simple HTTP server to capture crash reports
+def start_crash_server(port)
+  server = WEBrick::HTTPServer.new(
+    Port: port,
+    Logger: WEBrick::Log.new(File.open(File::NULL, "w")),
+    AccessLog: []
+  )
+
+  crash_report = nil
+
+  server.mount_proc '/' do |req, res|
+    if req.request_method == 'POST'
+      body = req.body
+      crash_report = JSON.parse(body) rescue body
+      puts "=== CRASH REPORT RECEIVED ==="
+      puts JSON.pretty_generate(crash_report) if crash_report.is_a?(Hash)
+      puts "=== END CRASH REPORT ==="
+    end
+    res.body = '{}'
+  end
+
+  Thread.new { server.start }
+  [server, proc { crash_report }]
+end
+
+# Nested Ruby functions to create a meaningful stack
+def level_5
+  puts "In level_5 - about to crash"
+  # Trigger segfault
+  Fiddle.free(42)
+end
+
+def level_4
+  puts "In level_4"
+  level_5
+end
+
+def level_3
+  puts "In level_3"
+  level_4
+end
+
+def level_2
+  puts "In level_2"
+  level_3
+end
+
+def level_1
+  puts "In level_1"
+  level_2
+end
+
+def main_crash_test
+  puts "Starting crash test with nested functions"
+  level_1
+end
+
+# Main test
+puts "Starting standalone crashtracker test..."
+
+# Start server
+server, get_crash_report = start_crash_server(9999)
+sleep 0.1 # Let server start
+
+puts "Forking process to test crashtracker..."
+
+pid = fork do
+  begin
+    puts "Child process started"
+
+    # Configure crashtracker
+    Datadog.configure do |c|
+      c.agent.host = '127.0.0.1'
+      c.agent.port = 9999
+    end
+
+    puts "Crashtracker configured, starting crash test..."
+
+    # Call our nested function that will crash
+    main_crash_test
+
+  rescue => e
+    puts "Unexpected error in child: #{e}"
+    exit 1
+  end
+end
+
+# Wait for child process
+Process.wait(pid)
+puts "Child process finished with status: #{$?.exitstatus}"
+
+# Give server time to receive the crash report
+sleep 1
+
+# Get and save the crash report
+crash_report = get_crash_report.call
+if crash_report
+  # Write full crash report to tmp file
+  timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+  crash_file = "/tmp/crashtracker_report_#{timestamp}.json"
+  File.write(crash_file, JSON.pretty_generate(crash_report))
+  puts "\n=== CRASH REPORT SAVED ==="
+  puts "Full crash report written to: #{crash_file}"
+
+  puts "\n=== RUNTIME STACK ANALYSIS ==="
+  if crash_report.is_a?(Hash) && crash_report.dig('payload', 0, 'message')
+    message = JSON.parse(crash_report.dig('payload', 0, 'message'))
+    runtime_stack = message['experimental']['runtime_stack']
+    if runtime_stack
+      puts "Runtime stack format: #{runtime_stack['format']}"
+      puts "Number of frames captured: #{runtime_stack['frames']&.length || 0}"
+      puts "\nStack frames:"
+      runtime_stack['frames']&.each_with_index do |frame, i|
+        puts "  [#{i}] #{frame['function']} @ #{frame['file']}:#{frame['line']}"
+      end
+
+      runtime_stack_file = "/tmp/runtime_stack_#{timestamp}.json"
+      File.write(runtime_stack_file, JSON.pretty_generate(runtime_stack))
+      puts "\nRuntime stack saved to: #{runtime_stack_file}"
+    else
+      puts "No runtime_stack found in crash report"
+    end
+  else
+    puts "Could not parse crash report structure"
+  end
+else
+  puts "No crash report received"
+end
+
+# Cleanup
+server.shutdown
+puts "\nTest complete."

ext/libdatadog_api/crashtracker.c

@@ -37,6 +37,12 @@
 #include <sys/mman.h>
 #include <unistd.h>
 #include <errno.h>
+#include <string.h>
+
+// Helper macro for creating CharSlice from C strings at runtime
+// This safely converts a const char* to ddog_CharSlice with proper length calculation
+#define DDOG_CHARSLICE_FROM_CSTR(cstr) \
+  ((cstr != NULL) ? (ddog_CharSlice){ .ptr = (cstr), .len = strlen(cstr) } : (ddog_CharSlice){ .ptr = NULL, .len = 0 })
 
 // Include profiling stack walking functionality
 // Note: rb_iseq_path and rb_iseq_base_label are already declared in MJIT header
@@ -52,8 +58,7 @@ static VALUE _native_register_runtime_stack_callback(VALUE _self, VALUE callback
 static VALUE _native_is_runtime_callback_registered(DDTRACE_UNUSED VALUE _self);
 
 static void ruby_runtime_stack_callback(
-  void (*emit_frame)(const ddog_crasht_RuntimeStackFrame*),
-  void (*emit_stacktrace_string)(const char*)
+  void (*emit_frame)(const ddog_crasht_RuntimeStackFrame*)
 );
 
 static bool first_init = true;
@@ -67,7 +72,7 @@ static bool is_pointer_readable(const void *ptr, size_t size) {
   size_t pages = ((char*)ptr + size - (char*)aligned_ptr + page_size - 1) / page_size;
 
   // Stack-allocate a small buffer for mincore results.. should be safe?
-  char vec[16];
+  unsigned char vec[16];
   if (pages > 16) return false; // Too big to check safely
 
   return mincore(aligned_ptr, pages * page_size, vec) == 0;
@@ -248,12 +253,9 @@ static VALUE _native_stop(DDTRACE_UNUSED VALUE _self) {
   return Qtrue;
 }
 
-
 static void ruby_runtime_stack_callback(
-  void (*emit_frame)(const ddog_crasht_RuntimeStackFrame*),
-  void (*emit_stacktrace_string)(const char*)
+  void (*emit_frame)(const ddog_crasht_RuntimeStackFrame*)
 ) {
-  (void)emit_stacktrace_string;
 
   VALUE current_thread = rb_thread_current();
   if (current_thread == Qnil) return;
@@ -337,8 +339,8 @@ static void ruby_runtime_stack_callback(
       }
 
       ddog_crasht_RuntimeStackFrame frame = {
-        .function_name = function_name,
-        .file_name = file_name,
+        .function_name = DDOG_CHARSLICE_FROM_CSTR(function_name),
+        .file_name = DDOG_CHARSLICE_FROM_CSTR(file_name),
         .line_number = line_no,
         .column_number = 0
       };
@@ -365,8 +367,8 @@ static void ruby_runtime_stack_callback(
       }
 
       ddog_crasht_RuntimeStackFrame frame = {
-        .function_name = function_name,
-        .file_name = file_name,
+        .function_name = DDOG_CHARSLICE_FROM_CSTR(function_name),
+        .file_name = DDOG_CHARSLICE_FROM_CSTR(file_name),
         .line_number = 0,
         .column_number = 0
       };
@@ -385,17 +387,15 @@ static VALUE _native_register_runtime_stack_callback(DDTRACE_UNUSED VALUE _self,
     rb_raise(rb_eArgError, "Invalid callback_type. Only :frame is supported");
   }
 
-  enum ddog_crasht_CallbackResult result = ddog_crasht_register_runtime_stack_callback(
-    ruby_runtime_stack_callback,
-    DDOG_CRASHT_CALLBACK_TYPE_FRAME
+  enum ddog_crasht_CallbackResult result = ddog_crasht_register_runtime_frame_callback(
+    ruby_runtime_stack_callback
   );
 
   switch (result) {
     case DDOG_CRASHT_CALLBACK_RESULT_OK:
       return Qtrue;
-    case DDOG_CRASHT_CALLBACK_RESULT_ERROR:
-      rb_raise(rb_eRuntimeError, "Failed to register runtime callback");
-      break;
+    default:
+      return Qfalse;
   }
 
   return Qfalse;