Introduce shm limiter

Signed-off-by: Bob Weinand <[email protected]>

Author: bwoebi

ipc/src/platform/mem_handle.rs

@@ -214,7 +214,7 @@ mod tests {
         let shm = ShmHandle::new(5).unwrap();
         let mut mapped = shm.map().unwrap();
         _ = mapped.as_slice_mut().write(&[1, 2, 3, 4, 5]).unwrap();
-        let mapped = mapped.ensure_space(100000);
+        mapped.ensure_space(100000);
         assert!(mapped.as_slice().len() >= 100000);
         let mut exp = vec![0u8; mapped.as_slice().len()];
         _ = (&mut exp[..5]).write(&[1, 2, 3, 4, 5]).unwrap();
@@ -228,7 +228,7 @@ mod tests {
         let shm = NamedShmHandle::create(path.clone(), 5).unwrap();
         let mut mapped = shm.map().unwrap();
         _ = mapped.as_slice_mut().write(&[1, 2, 3, 4, 5]).unwrap();
-        let mapped = mapped.ensure_space(100000);
+        mapped.ensure_space(100000);
         assert!(mapped.as_slice().len() >= 100000);
 
         let other = NamedShmHandle::open(&path).unwrap().map().unwrap();

ipc/src/platform/unix/mem_handle.rs

@@ -107,14 +107,15 @@ impl NamedShmHandle {
 }
 
 impl<T: FileBackedHandle + From<MappedMem<T>>> MappedMem<T> {
-    pub fn ensure_space(self, expected_size: usize) -> MappedMem<T> {
+    pub fn ensure_space(&mut self, expected_size: usize) {
         if expected_size <= self.mem.get_shm().size {
-            return self;
+            return;
         }
 
-        let mut handle: T = self.into();
+        // SAFETY: we'll overwrite the original memory later
+        let mut handle: T = unsafe { std::ptr::read(self) }.into();
         _ = handle.resize(expected_size);
-        handle.map().unwrap()
+        unsafe { std::ptr::write(self, handle.map().unwrap()) };
     }
 }
 

ipc/src/platform/unix/mem_handle_macos.rs

@@ -126,9 +126,9 @@ impl NamedShmHandle {
 }
 
 impl<T: FileBackedHandle + From<MappedMem<T>>> MappedMem<T> {
-    pub fn ensure_space(self, expected_size: usize) -> MappedMem<T> {
+    pub fn ensure_space(&mut self, expected_size: usize) {
         if expected_size <= self.mem.get_shm().size {
-            return self;
+            return;
         }
         if expected_size > MAPPING_MAX_SIZE - page_size::get() {
             panic!(
@@ -138,7 +138,9 @@ impl<T: FileBackedHandle + From<MappedMem<T>>> MappedMem<T> {
             );
         }
 
-        let mut handle: T = self.into();
+        // SAFETY: we'll overwrite the original memory later
+        let mut handle: T = unsafe { std::ptr::read(self) }.into();
+
         let page_size = NonZeroUsize::try_from(page_size::get()).unwrap();
         unsafe {
             _ = handle.set_mapping_size(expected_size);
@@ -156,7 +158,8 @@ impl<T: FileBackedHandle + From<MappedMem<T>>> MappedMem<T> {
             size.fetch_max(handle.get_size(), Ordering::SeqCst);
             _ = munmap(ptr, usize::from(page_size));
         }
-        handle.map().unwrap()
+
+        unsafe { std::ptr::write(self, handle.map().unwrap()) };
     }
 }
 

ipc/src/platform/windows/mem_handle.rs

@@ -151,10 +151,10 @@ impl NamedShmHandle {
 }
 
 impl<T: FileBackedHandle + From<MappedMem<T>>> MappedMem<T> {
-    pub fn ensure_space(mut self, expected_size: usize) -> MappedMem<T> {
+    pub fn ensure_space(&mut self, expected_size: usize) {
         let current_size = self.mem.get_shm().size;
         if expected_size <= current_size {
-            return self;
+            return;
         }
         if expected_size > MAPPING_MAX_SIZE {
             panic!(
@@ -175,6 +175,5 @@ impl<T: FileBackedHandle + From<MappedMem<T>>> MappedMem<T> {
                 PAGE_READWRITE,
             )
         };
-        self
     }
 }

live-debugger-ffi/src/data.rs

@@ -3,8 +3,8 @@
 
 use datadog_live_debugger::debugger_defs::{ProbeMetadata, ProbeMetadataLocation};
 use datadog_live_debugger::{
-    Capture, DslString, EvaluateAt, InBodyLocation, MetricKind, ProbeCondition, ProbeValue,
-    SpanProbeTarget,
+    CaptureConfiguration, DslString, EvaluateAt, InBodyLocation, MetricKind, ProbeCondition,
+    ProbeValue, SpanProbeTarget,
 };
 use ddcommon_ffi::slice::AsBytes;
 use ddcommon_ffi::{CharSlice, Option};
@@ -60,7 +60,7 @@ impl<'a> From<&'a datadog_live_debugger::MetricProbe> for MetricProbe<'a> {
 pub struct LogProbe<'a> {
     pub segments: &'a DslString,
     pub when: &'a ProbeCondition,
-    pub capture: &'a Capture,
+    pub capture: &'a CaptureConfiguration,
     pub capture_snapshot: bool,
     pub sampling_snapshots_per_second: u32,
 }
@@ -291,6 +291,7 @@ impl<'a> From<&'a datadog_live_debugger::LiveDebuggingData> for LiveDebuggingDat
     }
 }
 
-pub extern "C" fn ddog_capture_defaults() -> Capture {
-    Capture::default()
+#[no_mangle]
+pub extern "C" fn ddog_capture_defaults() -> CaptureConfiguration {
+    CaptureConfiguration::default()
 }

live-debugger-ffi/src/evaluator.rs

@@ -2,7 +2,7 @@
 // License Version 2.0. This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021-Present Datadog, Inc.
 
 use datadog_live_debugger::debugger_defs::SnapshotEvaluationError;
-use datadog_live_debugger::{DslString, ProbeCondition};
+use datadog_live_debugger::{DslString, ProbeCondition, ProbeValue};
 use ddcommon_ffi::slice::AsBytes;
 use ddcommon_ffi::CharSlice;
 use std::borrow::Cow;
@@ -226,13 +226,8 @@ extern "C" fn ddog_drop_void_collection_string(void: VoidCollection) {
     }
 }
 
-#[no_mangle]
-pub extern "C" fn ddog_evaluate_unmanaged_string(
-    segments: &DslString,
-    context: &mut c_void,
-    errors: &mut Option<Box<Vec<SnapshotEvaluationError>>>,
-) -> VoidCollection {
-    let string = ddog_evaluate_string(segments, context, errors).to_string();
+fn into_void_collection_string(s: &dyn ToString) -> VoidCollection {
+    let string = s.to_string();
     let new = VoidCollection {
         count: string.len() as isize,
         elements: string.as_ptr() as *const c_void,
@@ -241,3 +236,58 @@ pub extern "C" fn ddog_evaluate_unmanaged_string(
     std::mem::forget(string);
     new
 }
+
+#[no_mangle]
+pub extern "C" fn ddog_evaluate_unmanaged_string(
+    segments: &DslString,
+    context: &mut c_void,
+    errors: &mut Option<Box<Vec<SnapshotEvaluationError>>>,
+) -> VoidCollection {
+    into_void_collection_string(&ddog_evaluate_string(segments, context, errors))
+}
+
+pub struct InternalIntermediateValue<'a>(datadog_live_debugger::IntermediateValue<'a, c_void>);
+
+#[repr(C)]
+pub enum ValueEvaluationResult<'a> {
+    Success(Box<InternalIntermediateValue<'a>>),
+    Error(Box<Vec<SnapshotEvaluationError>>),
+}
+
+#[no_mangle]
+pub extern "C" fn ddog_evaluate_value<'a>(
+    value: &'a ProbeValue,
+    context: &'a mut c_void,
+) -> ValueEvaluationResult<'a> {
+    let mut ctx = EvalCtx::new(context);
+    match datadog_live_debugger::eval_value(&mut ctx, value) {
+        Ok(value) => ValueEvaluationResult::Success(Box::new(InternalIntermediateValue(value))),
+        Err(error) => ValueEvaluationResult::Error(Box::new(vec![error])),
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn ddog_evaluated_value_get<'a>(
+    value: &'a InternalIntermediateValue<'a>,
+) -> IntermediateValue<'a> {
+    (&value.0).into()
+}
+
+#[no_mangle]
+pub extern "C" fn ddog_evaluated_value_drop(_: Box<InternalIntermediateValue>) {}
+
+pub fn ddog_evaluated_value_into_string<'a>(
+    value: Box<InternalIntermediateValue<'a>>,
+    context: &'a mut c_void,
+) -> Cow<'a, str> {
+    let mut ctx = EvalCtx::new(context);
+    datadog_live_debugger::eval_intermediate_to_string(&mut ctx, value.0)
+}
+
+#[no_mangle]
+pub extern "C" fn ddog_evaluated_value_into_unmanaged_string<'a>(
+    value: Box<InternalIntermediateValue<'a>>,
+    context: &'a mut c_void,
+) -> VoidCollection {
+    into_void_collection_string(&ddog_evaluated_value_into_string(value, context))
+}

live-debugger-ffi/src/sender.rs

@@ -3,11 +3,13 @@
 
 use ddcommon_ffi::CharSlice;
 use std::borrow::Cow;
+use std::collections::hash_map;
+use std::mem::transmute;
 // Alias to prevent cbindgen panic
 use crate::data::Probe;
 use datadog_live_debugger::debugger_defs::{
-    Capture as DebuggerCaptureAlias, Captures, DebuggerData, DebuggerPayload, Entry, Fields,
-    Snapshot, SnapshotEvaluationError, Value as DebuggerValueAlias,
+    Capture as DebuggerCaptureAlias, Capture, Captures, DebuggerData, DebuggerPayload, Entry,
+    Fields, Snapshot, SnapshotEvaluationError, Value as DebuggerValueAlias,
 };
 use datadog_live_debugger::sender::generate_new_id;
 use ddcommon_ffi::slice::AsBytes;
@@ -94,7 +96,7 @@ pub extern "C" fn ddog_create_exception_snapshot<'a>(
         debugger: DebuggerData {
             snapshot: Snapshot {
                 captures: Some(Captures {
-                    r#return: Some(DebuggerCaptureAlias::default()),
+                    r#return: Some(Capture::default()),
                     ..Default::default()
                 }),
                 language: language.to_utf8_lossy(),
@@ -107,38 +109,33 @@ pub extern "C" fn ddog_create_exception_snapshot<'a>(
     };
     buffer.push(snapshot);
     unsafe {
-        std::mem::transmute(
-            buffer
-                .last_mut()
-                .unwrap()
-                .debugger
-                .snapshot
-                .captures
-                .as_mut()
-                .unwrap()
-                .r#return
-                .as_mut()
-                .unwrap(),
-        )
+        let captures = buffer
+            .last_mut()
+            .unwrap()
+            .debugger
+            .snapshot
+            .captures
+            .as_mut();
+        transmute(captures.unwrap().r#return.as_mut().unwrap())
     }
 }
 
+#[no_mangle]
 pub extern "C" fn ddog_create_log_probe_snapshot<'a>(
-    buffer: &mut Box<DebuggerPayload<'a>>,
     probe: &'a Probe,
+    message: Option<&CharSlice<'a>>,
     service: CharSlice<'a>,
     language: CharSlice<'a>,
     timestamp: u64,
-) -> *mut DebuggerCapture<'a> {
-    *buffer = Box::new(DebuggerPayload {
+) -> Box<DebuggerPayload<'a>> {
+    Box::new(DebuggerPayload {
         service: service.to_utf8_lossy(),
         source: "dd_debugger",
         timestamp,
-        message: None,
+        message: message.map(|m| m.to_utf8_lossy()),
         debugger: DebuggerData {
             snapshot: Snapshot {
                 captures: Some(Captures {
-                    r#return: Some(DebuggerCaptureAlias::default()),
                     ..Default::default()
                 }),
                 language: language.to_utf8_lossy(),
@@ -148,20 +145,69 @@ pub extern "C" fn ddog_create_log_probe_snapshot<'a>(
                 ..Default::default()
             },
         },
-    });
-    unsafe {
-        std::mem::transmute(
-            buffer
-                .debugger
-                .snapshot
-                .captures
-                .as_mut()
-                .unwrap()
-                .r#return
-                .as_mut()
-                .unwrap(),
-        )
-    }
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn ddog_update_payload_message<'a>(
+    payload: &mut DebuggerPayload<'a>,
+    message: CharSlice<'a>,
+) {
+    payload.message = Some(message.to_utf8_lossy());
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn ddog_snapshot_entry<'a>(
+    payload: &mut DebuggerPayload<'a>,
+) -> *mut DebuggerCapture<'a> {
+    transmute(
+        payload
+            .debugger
+            .snapshot
+            .captures
+            .as_mut()
+            .unwrap()
+            .entry
+            .insert(Capture::default()),
+    )
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn ddog_snapshot_lines<'a>(
+    payload: &mut DebuggerPayload<'a>,
+    line: u32,
+) -> *mut DebuggerCapture<'a> {
+    transmute(
+        match payload
+            .debugger
+            .snapshot
+            .captures
+            .as_mut()
+            .unwrap()
+            .lines
+            .entry(line)
+        {
+            hash_map::Entry::Occupied(e) => e.into_mut(),
+            hash_map::Entry::Vacant(e) => e.insert(Capture::default()),
+        },
+    )
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn ddog_snapshot_exit<'a>(
+    payload: &mut DebuggerPayload<'a>,
+) -> *mut DebuggerCapture<'a> {
+    transmute(
+        payload
+            .debugger
+            .snapshot
+            .captures
+            .as_mut()
+            .unwrap()
+            .r#return
+            .as_mut()
+            .unwrap(),
+    )
 }
 
 #[no_mangle]
@@ -241,7 +287,10 @@ pub extern "C" fn ddog_evaluation_error_snapshot<'a>(
         service: service.to_utf8_lossy(),
         source: "dd_debugger",
         timestamp,
-        message: Some(format!("Evaluation errors for probe id {}", probe.id)),
+        message: Some(Cow::Owned(format!(
+            "Evaluation errors for probe id {}",
+            probe.id
+        ))),
         debugger: DebuggerData {
             snapshot: Snapshot {
                 language: language.to_utf8_lossy(),

live-debugger/src/debugger_defs.rs

@@ -11,7 +11,7 @@ pub struct DebuggerPayload<'a> {
     pub source: &'static str,
     pub timestamp: u64,
     pub debugger: DebuggerData<'a>,
-    pub message: Option<String>,
+    pub message: Option<Cow<'a, str>>,
 }
 
 #[derive(Serialize, Deserialize)]