Only send frame and construct JSON array in receiver

Author: gyuheon0h

datadog-crashtracker/src/collector/emitters.rs

@@ -253,11 +253,7 @@ fn emit_runtime_stack_by_frames(w: &mut impl Write) -> Result<(), EmitterError>
     writeln!(w, "{DD_CRASHTRACK_BEGIN_RUNTIME_STACK_FRAME}")?;
 
     // JSON array for frames
-    write!(w, "[")?;
     unsafe { invoke_runtime_callback_with_writer(w)? };
-    write!(w, "]")?;
-
-    writeln!(w)?;
     writeln!(w, "{DD_CRASHTRACK_END_RUNTIME_STACK_FRAME}")?;
     w.flush()?;
     Ok(())
@@ -268,7 +264,6 @@ fn emit_runtime_stack_by_stacktrace_string(w: &mut impl Write) -> Result<(), Emi
 
     // Emit the stacktrace string
     unsafe { invoke_runtime_callback_with_writer(w)? };
-
     writeln!(w, "{DD_CRASHTRACK_END_RUNTIME_STACK_STRING}")?;
     w.flush()?;
     Ok(())

datadog-crashtracker/src/receiver/receive_report.rs

@@ -57,7 +57,7 @@ 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,
+    RuntimeStackFrame(Vec<RuntimeFrame>),
     RuntimeStackString(Vec<String>),
 }
 
@@ -135,41 +135,29 @@ fn process_line(
             builder.with_proc_info(proc_info)?;
             StdinState::ProcInfo
         }
-        StdinState::RuntimeStackFrame
+        StdinState::RuntimeStackFrame(frames)
             if line.starts_with(DD_CRASHTRACK_END_RUNTIME_STACK_FRAME) =>
         {
+            let runtime_stack = RuntimeStack {
+                format: "Datadog Runtime Callback 1.0".to_string(),
+                frames,
+                stacktrace_string: None,
+            };
+            builder.with_experimental_runtime_stack(runtime_stack)?;
             StdinState::Waiting
         }
-        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,
-                    };
-                    builder.with_experimental_runtime_stack(runtime_stack)?;
-                }
-            } else {
-                builder.with_log_message(
-                    format!("Unable to parse runtime stack frames: {line}"),
-                    true,
-                )?;
-            }
-            StdinState::RuntimeStackFrame
+        StdinState::RuntimeStackFrame(mut frames) => {
+            let frame = serde_json::from_str(line)?;
+            frames.push(frame);
+            StdinState::RuntimeStackFrame(frames)
         }
         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
-            // This is necessary because although the stacktrace string is sent as a single string,
-            // there may be newlines in the string
-            let stacktrace_string = lines.join("\n");
             let runtime_stack = RuntimeStack {
                 format: "Datadog Runtime Callback 1.0".to_string(),
                 frames: vec![],
-                stacktrace_string: Some(stacktrace_string),
+                stacktrace_string: Some(lines.join("\n")),
             };
             builder.with_experimental_runtime_stack(runtime_stack)?;
             StdinState::Waiting
@@ -254,7 +242,7 @@ fn process_line(
             StdinState::RuntimeStackString(vec![])
         }
         StdinState::Waiting if line.starts_with(DD_CRASHTRACK_BEGIN_RUNTIME_STACK_FRAME) => {
-            StdinState::RuntimeStackFrame
+            StdinState::RuntimeStackFrame(vec![])
         }
         StdinState::Waiting if line.starts_with(DD_CRASHTRACK_BEGIN_TRACE_IDS) => {
             StdinState::TraceIds

datadog-crashtracker/src/runtime_callback.rs

@@ -259,18 +259,13 @@ pub(crate) unsafe fn invoke_runtime_callback_with_writer<W: std::io::Write>(
     // the vtable for its impls, so we need to store both.
     static CURRENT_WRITER_DATA: AtomicPtr<()> = AtomicPtr::new(ptr::null_mut());
     static CURRENT_WRITER_VTABLE: AtomicPtr<()> = AtomicPtr::new(ptr::null_mut());
-    static CURRENT_FRAME_COUNT: AtomicPtr<usize> = AtomicPtr::new(ptr::null_mut());
-
-    let mut frame_count = 0usize;
 
     let writer_trait_obj: *mut dyn std::io::Write = writer;
     let writer_parts: (*mut (), *mut ()) = unsafe { std::mem::transmute(writer_trait_obj) };
-    let frame_count_ptr = &mut frame_count as *mut usize;
 
     // Store components atomically
     CURRENT_WRITER_DATA.store(writer_parts.0, Ordering::SeqCst);
     CURRENT_WRITER_VTABLE.store(writer_parts.1, Ordering::SeqCst);
-    CURRENT_FRAME_COUNT.store(frame_count_ptr, Ordering::SeqCst);
 
     // Define the emit functions that read from the atomic storage
     unsafe extern "C" fn emit_frame_collector(frame: *const RuntimeStackFrame) {
@@ -280,28 +275,19 @@ pub(crate) unsafe fn invoke_runtime_callback_with_writer<W: std::io::Write>(
 
         let writer_data = CURRENT_WRITER_DATA.load(Ordering::SeqCst);
         let writer_vtable = CURRENT_WRITER_VTABLE.load(Ordering::SeqCst);
-        let frame_count_ptr = CURRENT_FRAME_COUNT.load(Ordering::SeqCst);
 
-        if writer_data.is_null() || writer_vtable.is_null() || frame_count_ptr.is_null() {
+        if writer_data.is_null() || writer_vtable.is_null() {
             return;
         }
 
         // Reconstruct fat pointer
         let writer_trait_obj: *mut dyn std::io::Write =
             std::mem::transmute((writer_data, writer_vtable));
         let writer = &mut *writer_trait_obj;
-        let frame_count = &mut *frame_count_ptr;
-
-        // Add comma separator for frames after the first
-        if *frame_count > 0 {
-            let _ = write!(writer, ", ");
-        }
 
         // Write the frame as JSON
         let _ = emit_frame_as_json(writer, frame);
         let _ = writer.flush();
-
-        *frame_count += 1;
     }
 
     unsafe extern "C" fn emit_stacktrace_string_collector(stacktrace_string: *const c_char) {
@@ -339,7 +325,6 @@ pub(crate) unsafe fn invoke_runtime_callback_with_writer<W: std::io::Write>(
     // Clear atomic storage
     CURRENT_WRITER_DATA.store(ptr::null_mut(), Ordering::SeqCst);
     CURRENT_WRITER_VTABLE.store(ptr::null_mut(), Ordering::SeqCst);
-    CURRENT_FRAME_COUNT.store(ptr::null_mut(), Ordering::SeqCst);
 
     Ok(())
 }
@@ -411,7 +396,7 @@ unsafe fn emit_frame_as_json(
         write!(writer, "\"column\": {}", frame_ref.column_number)?;
     }
 
-    write!(writer, "}}")?;
+    writeln!(writer, "}}")?;
     Ok(())
 }