Live debugger parsing, expression evaluation, sender, redaction and F…

…FI (#497)

All stuff for live debugging.

.github/workflows/lint.yml

@@ -49,7 +49,7 @@ jobs:
         shell: bash
         run: |
           # shellcheck disable=SC2046
-          cargo clippy --workspace --all-targets --all-features -- -D warnings $([ ${{ matrix.rust_version }} = 1.76.0 ] && echo -Aunknown-lints -Ainvalid_reference_casting)
+          cargo clippy --workspace --all-targets --all-features -- -D warnings $([ ${{ matrix.rust_version }} = 1.76.0 ] && echo -Aunknown-lints -Ainvalid_reference_casting -Aclippy::redundant-closure-call)
   licensecheck:
     runs-on: ubuntu-latest
     name: "Presence of licence headers"

Cargo.toml

@@ -18,6 +18,9 @@ members = [
   "tools",
   "ipc",
   "ipc/macros",
+  "live-debugger",
+  "live-debugger-ffi",
+  "remote-config",
   "sidecar",
   "sidecar/macros",
   "sidecar-ffi",

ddcommon-ffi/src/option.rs

@@ -12,6 +12,13 @@ impl<T> Option<T> {
     pub fn to_std(self) -> std::option::Option<T> {
         self.into()
     }
+
+    pub fn to_std_ref(&self) -> std::option::Option<&T> {
+        match self {
+            Option::Some(ref s) => Some(s),
+            Option::None => None,
+        }
+    }
 }
 
 impl<T> From<Option<T>> for std::option::Option<T> {

ddcommon-ffi/src/slice.rs

@@ -76,6 +76,13 @@ pub trait AsBytes<'a> {
     fn to_utf8_lossy(&self) -> Cow<'a, str> {
         String::from_utf8_lossy(self.as_bytes())
     }
+
+    #[inline]
+    /// # Safety
+    /// Must only be used when the underlying data was already confirmed to be utf8.
+    unsafe fn assume_utf8(&self) -> &'a str {
+        std::str::from_utf8_unchecked(self.as_bytes())
+    }
 }
 
 impl<'a> AsBytes<'a> for Slice<'a, u8> {

ddcommon-ffi/src/vec.rs

@@ -8,6 +8,7 @@ use core::ops::Deref;
 use std::io::Write;
 use std::marker::PhantomData;
 use std::mem::ManuallyDrop;
+use std::ptr::NonNull;
 
 /// Holds the raw parts of a Rust Vec; it should only be created from Rust,
 /// never from C.
@@ -97,6 +98,15 @@ impl<T> Vec<T> {
     pub fn as_slice(&self) -> Slice<T> {
         unsafe { Slice::from_raw_parts(self.ptr, self.len) }
     }
+
+    pub const fn new() -> Self {
+        Vec {
+            ptr: NonNull::dangling().as_ptr(),
+            len: 0,
+            capacity: 0,
+            _marker: PhantomData,
+        }
+    }
 }
 
 impl<T> Deref for Vec<T> {
@@ -109,7 +119,7 @@ impl<T> Deref for Vec<T> {
 
 impl<T> Default for Vec<T> {
     fn default() -> Self {
-        Self::from(alloc::vec::Vec::new())
+        Self::new()
     }
 }
 

ddcommon/src/rate_limiter.rs

@@ -10,6 +10,8 @@ pub trait Limiter {
     /// Returns the effective rate per interval.
     /// Note: The rate is only guaranteed to be accurate immediately after a call to inc().
     fn rate(&self) -> f64;
+    /// Updates the rate and returns it
+    fn update_rate(&self) -> f64;
 }
 
 /// A thread-safe limiter built on Atomics.
@@ -83,23 +85,28 @@ impl LocalLimiter {
         self.last_limit.store(0, Ordering::Relaxed);
         self.granularity = TIME_PER_SECOND * seconds as i64;
     }
-}
 
-impl Limiter for LocalLimiter {
-    fn inc(&self, limit: u32) -> bool {
+    fn update(&self, limit: u32, inc: i64) -> i64 {
         let now = now();
         let last = self.last_update.swap(now, Ordering::SeqCst);
         // Make sure reducing the limit doesn't stall for a long time
         let clear_limit = limit.max(self.last_limit.load(Ordering::Relaxed));
         let clear_counter = (now as i64 - last as i64) * (clear_limit as i64);
-        let subtract = clear_counter - self.granularity;
+        let subtract = clear_counter - inc;
         let mut previous_hits = self.hit_count.fetch_sub(subtract, Ordering::SeqCst);
         // Handle where the limiter goes below zero
         if previous_hits < subtract {
             let add = clear_counter - previous_hits.max(0);
             self.hit_count.fetch_add(add, Ordering::Acquire);
             previous_hits += add - clear_counter;
         }
+        previous_hits
+    }
+}
+
+impl Limiter for LocalLimiter {
+    fn inc(&self, limit: u32) -> bool {
+        let previous_hits = self.update(limit, self.granularity);
         if previous_hits / self.granularity >= limit as i64 {
             self.hit_count
                 .fetch_sub(self.granularity, Ordering::Acquire);
@@ -119,6 +126,11 @@ impl Limiter for LocalLimiter {
         let hit_count = self.hit_count.load(Ordering::Relaxed);
         (hit_count as f64 / (last_limit as i64 * self.granularity) as f64).clamp(0., 1.)
     }
+
+    fn update_rate(&self) -> f64 {
+        self.update(0, self.granularity);
+        self.rate()
+    }
 }
 
 #[cfg(test)]

ipc/src/platform/mem_handle.rs

@@ -147,6 +147,12 @@ impl<T: MemoryHandle> MappedMem<T> {
     }
 }
 
+impl<T: MemoryHandle> AsRef<[u8]> for MappedMem<T> {
+    fn as_ref(&self) -> &[u8] {
+        self.as_slice()
+    }
+}
+
 impl MappedMem<NamedShmHandle> {
     pub fn get_path(&self) -> &[u8] {
         self.mem.get_path()
@@ -205,12 +211,6 @@ impl From<ShmHandle> for PlatformHandle<OwnedFileHandle> {
 unsafe impl<T> Sync for MappedMem<T> where T: FileBackedHandle {}
 unsafe impl<T> Send for MappedMem<T> where T: FileBackedHandle {}
 
-impl AsRef<[u8]> for MappedMem<ShmHandle> {
-    fn as_ref(&self) -> &[u8] {
-        self.as_slice()
-    }
-}
-
 #[cfg(feature = "tiny-bytes")]
 impl UnderlyingBytes for MappedMem<ShmHandle> {}