fix(sidecar): Cleanup limiters on sidecar shutdown (#1659)

Not really a big problem, just not nice.

Co-authored-by: bob.weinand <bob.weinand@datadoghq.com>

Author: bwoebi

datadog-sidecar/src/service/exception_hash_rate_limiter.rs

@@ -6,15 +6,28 @@ use datadog_ipc::rate_limiter::{ShmLimiter, ShmLimiterMemory};
 use libdd_common::{rate_limiter::Limiter, MutexExt};
 use std::ffi::CString;
 use std::io;
+use std::mem::ManuallyDrop;
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{LazyLock, Mutex};
 use std::time::Duration;
 
-pub(crate) static EXCEPTION_HASH_LIMITER: LazyLock<Mutex<ManagedExceptionHashRateLimiter>> =
-    LazyLock::new(|| {
-        #[allow(clippy::unwrap_used)]
-        Mutex::new(ManagedExceptionHashRateLimiter::create().unwrap())
-    });
+pub(crate) static EXCEPTION_HASH_LIMITER: LazyLock<
+    Mutex<ManuallyDrop<ManagedExceptionHashRateLimiter>>,
+> = LazyLock::new(|| {
+    unsafe { libc::atexit(drop_exception_hash_limiter) };
+    #[allow(clippy::unwrap_used)]
+    Mutex::new(ManuallyDrop::new(
+        ManagedExceptionHashRateLimiter::create().unwrap(),
+    ))
+});
+
+extern "C" fn drop_exception_hash_limiter() {
+    let mut guard = EXCEPTION_HASH_LIMITER
+        .lock()
+        .unwrap_or_else(|e| e.into_inner());
+    // SAFETY: atexit runs once at program exit; no code accesses this static afterward.
+    unsafe { ManuallyDrop::drop(&mut *guard) };
+}
 
 pub(crate) struct ManagedExceptionHashRateLimiter {
     limiter: ExceptionHashRateLimiter,

datadog-sidecar/src/tracer.rs

@@ -8,14 +8,24 @@ use libdd_common::Endpoint;
 use libdd_trace_utils::config_utils::trace_intake_url_prefixed;
 use std::borrow::Cow;
 use std::ffi::CString;
+use std::mem::ManuallyDrop;
 use std::str::FromStr;
 use std::sync::{LazyLock, Mutex};
 
-pub static SHM_LIMITER: LazyLock<Mutex<ShmLimiterMemory<()>>> = LazyLock::new(|| {
+pub static SHM_LIMITER: LazyLock<Mutex<ManuallyDrop<ShmLimiterMemory<()>>>> = LazyLock::new(|| {
+    unsafe { libc::atexit(drop_shm_limiter) };
     #[allow(clippy::unwrap_used)]
-    Mutex::new(ShmLimiterMemory::create(shm_limiter_path()).unwrap())
+    Mutex::new(ManuallyDrop::new(
+        ShmLimiterMemory::create(shm_limiter_path()).unwrap(),
+    ))
 });
 
+extern "C" fn drop_shm_limiter() {
+    let mut guard = SHM_LIMITER.lock().unwrap_or_else(|e| e.into_inner());
+    // SAFETY: atexit runs once at program exit; no code accesses this static afterward.
+    unsafe { ManuallyDrop::drop(&mut *guard) };
+}
+
 #[derive(Default)]
 pub struct Config {
     pub endpoint: Option<Endpoint>,