Dont pass in runtime type

gyuheon0h · gyuheon0h · commit 5fad559ba9d3 · 2025-10-03T16:57:21.000Z
diff --git a/datadog-crashtracker-ffi/src/runtime_callback.rs b/datadog-crashtracker-ffi/src/runtime_callback.rs
@@ -6,14 +6,12 @@
 //! This module provides C-compatible FFI bindings for registering runtime-specific
 //! crash callbacks that can provide stack traces for dynamic languages.
 use datadog_crashtracker::{
-    get_registered_callback_type_ptr, get_registered_runtime_type_ptr,
-    is_runtime_callback_registered, register_runtime_stack_callback, CallbackError, CallbackType,
-    RuntimeStackCallback, RuntimeType,
+    get_registered_callback_type_ptr, is_runtime_callback_registered,
+    register_runtime_stack_callback, CallbackError, CallbackType, RuntimeStackCallback,
 };
 
 // Re-export the enums for C/C++ consumers
 pub use datadog_crashtracker::CallbackType as ddog_CallbackType;
-pub use datadog_crashtracker::RuntimeType as ddog_RuntimeType;
 
 pub use datadog_crashtracker::RuntimeStackFrame as ddog_RuntimeStackFrame;
 
@@ -75,7 +73,6 @@ impl From<CallbackError> for CallbackResult {
 ///
 /// ddog_CallbackResult result = ddog_crasht_register_runtime_stack_callback(
 ///     my_runtime_callback,
-///     RuntimeType::Ruby,
 ///     CallbackType::Frame,
 /// );
 /// ```
@@ -86,7 +83,6 @@ impl From<CallbackError> for CallbackResult {
 ///
 /// # Arguments
 /// - `callback`: The callback function to invoke during crashes
-/// - `runtime_type`: Runtime type enum (Python, Ruby, Php, Nodejs, Unknown)
 /// - `callback_type`: Callback type enum (Frame, StacktraceString)
 ///
 /// # Returns
@@ -99,10 +95,9 @@ impl From<CallbackError> for CallbackResult {
 #[no_mangle]
 pub unsafe extern "C" fn ddog_crasht_register_runtime_stack_callback(
     callback: RuntimeStackCallback,
-    runtime_type: RuntimeType,
     callback_type: CallbackType,
 ) -> CallbackResult {
-    match register_runtime_stack_callback(callback, runtime_type, callback_type) {
+    match register_runtime_stack_callback(callback, callback_type) {
         Ok(()) => CallbackResult::Ok,
         Err(e) => e.into(),
     }
@@ -119,20 +114,6 @@ pub extern "C" fn ddog_crasht_is_runtime_callback_registered() -> bool {
     is_runtime_callback_registered()
 }
 
-/// Get the runtime type from the currently registered callback context
-///
-/// Returns the runtime type C string pointer if a callback with valid context is registered,
-/// null pointer otherwise
-///
-/// # Safety
-/// - The returned pointer is valid only while the callback remains registered
-/// - The caller should not free the returned pointer
-/// - The returned string should be copied if it needs to persist beyond callback lifetime
-#[no_mangle]
-pub unsafe extern "C" fn ddog_crasht_get_registered_runtime_type() -> *const std::ffi::c_char {
-    get_registered_runtime_type_ptr()
-}
-
 /// Get the callback type from the currently registered callback context
 ///
 /// Returns the callback type C string pointer if a callback with valid context is registered,
@@ -191,12 +172,10 @@ mod tests {
 
             // Test that no callback is initially registered
             assert!(!ddog_crasht_is_runtime_callback_registered());
-            assert_eq!(ddog_crasht_get_registered_runtime_type(), ptr::null());
 
             // Test successful registration using type-safe enums
             let result = ddog_crasht_register_runtime_stack_callback(
                 test_runtime_callback,
-                RuntimeType::Ruby,
                 CallbackType::Frame,
             );
 
@@ -205,16 +184,9 @@ mod tests {
             // Verify callback is now registered
             assert!(ddog_crasht_is_runtime_callback_registered());
 
-            // Verify we can retrieve the runtime type
-            let runtime_type_ptr = ddog_crasht_get_registered_runtime_type();
-            assert!(!runtime_type_ptr.is_null());
-            let runtime_type_str = std::ffi::CStr::from_ptr(runtime_type_ptr).to_str().unwrap();
-            assert_eq!(runtime_type_str, "ruby");
-
             // Test duplicate registration fails
             let result = ddog_crasht_register_runtime_stack_callback(
                 test_runtime_callback,
-                RuntimeType::Ruby,
                 CallbackType::Frame,
             );
             assert_eq!(result, CallbackResult::Ok);
@@ -239,19 +211,12 @@ mod tests {
             // Test registration with enum values - Python + StacktraceString
             let result = ddog_crasht_register_runtime_stack_callback(
                 test_runtime_callback,
-                RuntimeType::Python,
                 CallbackType::StacktraceString,
             );
 
             assert_eq!(result, CallbackResult::Ok);
             assert!(ddog_crasht_is_runtime_callback_registered());
 
-            // Verify runtime type
-            let runtime_type_ptr = ddog_crasht_get_registered_runtime_type();
-            assert!(!runtime_type_ptr.is_null());
-            let runtime_type_str = std::ffi::CStr::from_ptr(runtime_type_ptr).to_str().unwrap();
-            assert_eq!(runtime_type_str, "python");
-
             // Verify callback type
             let callback_type_ptr = ddog_crasht_get_registered_callback_type();
             assert!(!callback_type_ptr.is_null());
@@ -263,17 +228,11 @@ mod tests {
             // Test re-registration with different values - Ruby + Frame
             let result = ddog_crasht_register_runtime_stack_callback(
                 test_runtime_callback,
-                RuntimeType::Ruby,
                 CallbackType::Frame,
             );
 
             assert_eq!(result, CallbackResult::Ok);
 
-            // Verify new values
-            let runtime_type_ptr = ddog_crasht_get_registered_runtime_type();
-            let runtime_type_str = std::ffi::CStr::from_ptr(runtime_type_ptr).to_str().unwrap();
-            assert_eq!(runtime_type_str, "ruby");
-
             let callback_type_ptr = ddog_crasht_get_registered_callback_type();
             let callback_type_str = std::ffi::CStr::from_ptr(callback_type_ptr)
                 .to_str()
diff --git a/datadog-crashtracker/src/collector/emitters.rs b/datadog-crashtracker/src/collector/emitters.rs
@@ -5,8 +5,8 @@ use crate::collector::additional_tags::consume_and_emit_additional_tags;
 use crate::collector::counters::emit_counters;
 use crate::collector::spans::{emit_spans, emit_traces};
 use crate::runtime_callback::{
-    get_registered_callback_type_enum, get_registered_runtime_type_enum,
-    invoke_runtime_callback_with_writer, is_runtime_callback_registered, CallbackType,
+    get_registered_callback_type_enum, invoke_runtime_callback_with_writer,
+    is_runtime_callback_registered, CallbackType,
 };
 use crate::shared::constants::*;
 use crate::{translate_si_code, CrashtrackerConfiguration, SignalNames, StacktraceCollection};
@@ -225,32 +225,21 @@ fn emit_ucontext(w: &mut impl Write, ucontext: *const ucontext_t) -> Result<(),
 ///     must be signal safe.
 fn emit_runtime_stack(w: &mut impl Write) -> Result<(), EmitterError> {
     let callback_type = unsafe { get_registered_callback_type_enum() };
-    let runtime_type = unsafe { get_registered_runtime_type_enum() };
 
     let callback_type = match callback_type {
         Some(ct) => ct,
         None => return Ok(()), // No callback registered
     };
 
-    let runtime_type_str = runtime_type.map(|rt| rt.as_str()).unwrap_or("unknown");
-
     match callback_type {
-        CallbackType::Frame => emit_runtime_stack_by_frames(w, runtime_type_str),
-        CallbackType::StacktraceString => {
-            emit_runtime_stack_by_stacktrace_string(w, runtime_type_str)
-        }
+        CallbackType::Frame => emit_runtime_stack_by_frames(w),
+        CallbackType::StacktraceString => emit_runtime_stack_by_stacktrace_string(w),
     }
 }
 
-fn emit_runtime_stack_by_frames(
-    w: &mut impl Write,
-    runtime_type: &str,
-) -> Result<(), EmitterError> {
+fn emit_runtime_stack_by_frames(w: &mut impl Write) -> Result<(), EmitterError> {
     writeln!(w, "{DD_CRASHTRACK_BEGIN_RUNTIME_STACK_FRAME}")?;
 
-    // Emit runtime type as metadata
-    writeln!(w, "{{\"runtime_type\": \"{runtime_type}\"}}")?;
-
     // JSON array for frames
     write!(w, "[")?;
     unsafe { invoke_runtime_callback_with_writer(w)? };
@@ -262,15 +251,9 @@ fn emit_runtime_stack_by_frames(
     Ok(())
 }
 
-fn emit_runtime_stack_by_stacktrace_string(
-    w: &mut impl Write,
-    runtime_type: &str,
-) -> Result<(), EmitterError> {
+fn emit_runtime_stack_by_stacktrace_string(w: &mut impl Write) -> Result<(), EmitterError> {
     writeln!(w, "{DD_CRASHTRACK_BEGIN_RUNTIME_STACK_STRING}")?;
 
-    // Emit runtime type as metadata
-    writeln!(w, "{{\"runtime_type\": \"{runtime_type}\"}}")?;
-
     // Emit the stacktrace string
     unsafe { invoke_runtime_callback_with_writer(w)? };
 
diff --git a/datadog-crashtracker/src/receiver/receive_report.rs b/datadog-crashtracker/src/receiver/receive_report.rs
@@ -57,8 +57,8 @@ pub(crate) enum StdinState {
     Waiting,
     // StackFrame is always emitted as one stream of all the frames but StackString
     // may have lines that we need to accumulate depending on runtime (e.g. Python)
-    RuntimeStackFrame(Option<String>),
-    RuntimeStackString(Vec<String>, Option<String>),
+    RuntimeStackFrame,
+    RuntimeStackString(Vec<String>),
 }
 
 /// A state machine that processes data from the crash-tracker collector line by
@@ -135,37 +135,26 @@ fn process_line(
             builder.with_proc_info(proc_info)?;
             StdinState::ProcInfo
         }
-        StdinState::RuntimeStackFrame(_runtime_type)
+        StdinState::RuntimeStackFrame
             if line.starts_with(DD_CRASHTRACK_END_RUNTIME_STACK_FRAME) =>
         {
             StdinState::Waiting
         }
-        StdinState::RuntimeStackFrame(runtime_type) => {
-            // Try to parse as metadata first
-            if let Ok(metadata) = serde_json::from_str::<serde_json::Value>(line) {
-                if let Some(rt) = metadata.get("runtime_type").and_then(|v| v.as_str()) {
-                    // This line contains metadata, store the runtime_type
-                    return Ok(StdinState::RuntimeStackFrame(Some(rt.to_string())));
-                }
-            }
-
+        StdinState::RuntimeStackFrame => {
             // Try to parse as frames array
             if let Ok(runtime_frames) = serde_json::from_str::<Vec<RuntimeFrame>>(line) {
                 if !runtime_frames.is_empty() {
                     let runtime_stack = RuntimeStack {
                         format: "Datadog Runtime Callback 1.0".to_string(),
                         frames: runtime_frames,
                         stacktrace_string: None,
-                        runtime_type: runtime_type
-                            .clone()
-                            .unwrap_or_else(|| "unknown".to_string()),
                     };
                     builder.with_experimental_runtime_stack(runtime_stack)?;
                 }
             }
-            StdinState::RuntimeStackFrame(runtime_type)
+            StdinState::RuntimeStackFrame
         }
-        StdinState::RuntimeStackString(lines, runtime_type)
+        StdinState::RuntimeStackString(lines)
             if line.starts_with(DD_CRASHTRACK_END_RUNTIME_STACK_STRING) =>
         {
             // Join all accumulated lines with newlines to reconstruct the full stack trace
@@ -174,25 +163,13 @@ fn process_line(
                 format: "Datadog Runtime Callback 1.0".to_string(),
                 frames: vec![],
                 stacktrace_string: Some(stacktrace_string),
-                runtime_type: runtime_type
-                    .clone()
-                    .unwrap_or_else(|| "unknown".to_string()),
             };
             builder.with_experimental_runtime_stack(runtime_stack)?;
             StdinState::Waiting
         }
-        StdinState::RuntimeStackString(mut lines, runtime_type) => {
-            // Try to parse as metadata first
-            if let Ok(metadata) = serde_json::from_str::<serde_json::Value>(line) {
-                if let Some(rt) = metadata.get("runtime_type").and_then(|v| v.as_str()) {
-                    // This line contains metadata, store the runtime_type
-                    return Ok(StdinState::RuntimeStackString(lines, Some(rt.to_string())));
-                }
-            }
-
-            // Otherwise, add as stacktrace content
+        StdinState::RuntimeStackString(mut lines) => {
             lines.push(line.to_string());
-            StdinState::RuntimeStackString(lines, runtime_type)
+            StdinState::RuntimeStackString(lines)
         }
         StdinState::SigInfo if line.starts_with(DD_CRASHTRACK_END_SIGINFO) => StdinState::Waiting,
         StdinState::SigInfo => {
@@ -267,10 +244,10 @@ fn process_line(
             StdinState::StackTrace
         }
         StdinState::Waiting if line.starts_with(DD_CRASHTRACK_BEGIN_RUNTIME_STACK_STRING) => {
-            StdinState::RuntimeStackString(vec![], None)
+            StdinState::RuntimeStackString(vec![])
         }
         StdinState::Waiting if line.starts_with(DD_CRASHTRACK_BEGIN_RUNTIME_STACK_FRAME) => {
-            StdinState::RuntimeStackFrame(None)
+            StdinState::RuntimeStackFrame
         }
         StdinState::Waiting if line.starts_with(DD_CRASHTRACK_BEGIN_TRACE_IDS) => {
             StdinState::TraceIds
diff --git a/datadog-crashtracker/src/runtime_callback.rs b/datadog-crashtracker/src/runtime_callback.rs
