fix(shared-runtime): make ForkSafeRuntime teardown structurally TLS/poison-safe

libdd-common/src/lib.rs

@@ -79,6 +79,17 @@ pub mod unix_utils;
 /// ```
 pub trait MutexExt<T> {
     fn lock_or_panic(&self) -> MutexGuard<'_, T>;
+
+    /// Acquires the lock, recovering the guard instead of panicking if poisoned.
+    /// Reserve for terminal teardown (`shutdown`/`Drop`); elsewhere prefer
+    /// [`MutexExt::lock_or_panic`] since poisoning there indicates a real bug.
+    ///
+    /// Default implementation just delegates to `lock_or_panic` (a safe, behavior-
+    /// preserving default for existing implementors); `Mutex<T>`'s impl below is the
+    /// one that actually recovers.
+    fn lock_or_recover(&self) -> MutexGuard<'_, T> {
+        self.lock_or_panic()
+    }
 }
 
 impl<T> MutexExt<T> for Mutex<T> {
@@ -88,6 +99,11 @@ impl<T> MutexExt<T> for Mutex<T> {
         #[allow(clippy::unwrap_used)]
         self.lock().unwrap()
     }
+
+    #[inline(always)]
+    fn lock_or_recover(&self) -> MutexGuard<'_, T> {
+        self.lock().unwrap_or_else(|poisoned| poisoned.into_inner())
+    }
 }
 
 /// Extension trait for `RwLock` to provide methods that acquire read/write locks, panicking if

libdd-data-pipeline/src/trace_exporter/mod.rs

@@ -258,10 +258,11 @@ impl<
     #[cfg(not(target_arch = "wasm32"))]
     pub fn shutdown(self, timeout: Option<Duration>) -> Result<(), TraceExporterError>
     where
-        R: BlockingRuntime,
+        R: BlockingRuntime + Send + Sync + 'static,
+        Self: Send,
     {
         let runtime = self.shared_runtime.clone();
-        runtime.block_on(self.shutdown_async(timeout))?
+        runtime.block_on_send(self.shutdown_async(timeout))?
     }
 
     /// Async version of [`Self::shutdown`].