Merge branch 'main' into anais/update-test-agent

Author: anais-raison

.github/workflows/release-proposal-dispatch.yml

@@ -116,6 +116,8 @@ jobs:
       contents: write
     needs: check-membership
     runs-on: ubuntu-latest
+    env:
+      RUSTUP_TOOLCHAIN: 1.92.0
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # 4.2.2
         with:
@@ -135,7 +137,7 @@ jobs:
         run: ln -sf ~/.rustup/toolchains/${{ steps.nightly-version.outputs.version }}-x86_64-unknown-linux-gnu ~/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu
       - uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: 1.92.0
+          toolchain: ${{ env.RUSTUP_TOOLCHAIN }}
       - uses: taiki-e/cache-cargo-install-action@7447f04c51f2ba27ca35e7f1e28fab848c5b3ba7 # 2.3.1
         with:
           tool: cargo-public-api@0.50.2

bin_tests/tests/crashtracker_bin_test.rs

@@ -21,8 +21,7 @@ use bin_tests::{
     ArtifactsBuild, BuildProfile,
 };
 use libdd_crashtracker::{
-    default_max_threads, CrashtrackerConfiguration, Metadata, SiCodes, SigInfo, SignalNames,
-    StacktraceCollection,
+    CrashtrackerConfiguration, Metadata, SiCodes, SigInfo, SignalNames, StacktraceCollection,
 };
 use serde_json::Value;
 
@@ -313,7 +312,7 @@ fn test_crash_tracking_multi_thread_collection() {
 #[cfg(target_os = "linux")]
 #[cfg_attr(miri, ignore)]
 fn test_crash_tracking_thread_limit() {
-    const THREAD_COUNT: usize = default_max_threads();
+    const THREAD_COUNT: usize = libdd_crashtracker::default_max_threads();
 
     let config = CrashTestConfig::new(
         BuildProfile::Release,

libdd-common/src/entity_id/unix/container_id.rs

@@ -11,6 +11,9 @@ use std::sync::LazyLock;
 
 const UUID_SOURCE: &str =
     r"[0-9a-f]{8}[-_][0-9a-f]{4}[-_][0-9a-f]{4}[-_][0-9a-f]{4}[-_][0-9a-f]{12}";
+/// PCF / Garden container UUID source: 8-4-4-4-4 hex (28 chars).
+/// Distinct from `UUID_SOURCE` (8-4-4-4-12) because the last group is 4 hex.
+const PCF_UUID_SOURCE: &str = r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}";
 const CONTAINER_SOURCE: &str = r"[0-9a-f]{64}";
 const TASK_SOURCE: &str = r"[0-9a-f]{32}-\d+";
 
@@ -22,7 +25,7 @@ pub(crate) static LINE_REGEX: LazyLock<Regex> = LazyLock::new(|| {
 pub(crate) static CONTAINER_REGEX: LazyLock<Regex> = LazyLock::new(|| {
     #[allow(clippy::unwrap_used)]
     Regex::new(&format!(
-        r"({UUID_SOURCE}|{CONTAINER_SOURCE}|{TASK_SOURCE})(?:\.scope(?:/[^/ \t]+)?)? *$"
+        r"({UUID_SOURCE}|{PCF_UUID_SOURCE}|{CONTAINER_SOURCE}|{TASK_SOURCE})(?:\.scope(?:/[^/ \t]+)?)? *$"
     ))
     .unwrap()
 });
@@ -92,6 +95,17 @@ mod tests {
             // invalid hex
             "13:name=systemd:/docker/3726184226f5d3147g25fdeab5b60097e378e8a720503a5e19ecfdf29f869860"
                 => None,
+            // PCF Garden 8-4-4-4-4 UUID
+            "1:name=systemd:/system.slice/garden.service/garden/6f265890-5165-7fab-6b52-18d1"
+                => Some("6f265890-5165-7fab-6b52-18d1"),
+            "10:freezer:/garden/6f265890-5165-7fab-6b52-18d1"
+                => Some("6f265890-5165-7fab-6b52-18d1"),
+            // Regression guard: 8-4-4-4-12 standard UUID must NOT be truncated to 28 chars
+            "1:name=systemd:/uuid/5a081c13-b8cf-4801-b427-f4601742204d"
+                => Some("5a081c13-b8cf-4801-b427-f4601742204d"),
+            // First group only 7 chars -> no match
+            "1:name=systemd:/garden/6f26589-5165-7fab-6b52-18d1"
+                => None,
         };
         for (line, &expected_result) in test_lines.iter() {
             assert_eq!(
@@ -118,6 +132,7 @@ mod tests {
             "cgroup.fargate" => Some("432624d2150b349fe35ba397284dea788c2bf66b885d14dfc1569b01890ca7da"),
             // parse a Fargate 1.4+ container ID
             "cgroup.fargate.1.4" => Some("8cd79a803caf4d2aa945152e934a5c00-1053176469"),
+            "cgroup.pcf" => Some("6f265890-5165-7fab-6b52-18d1"),
 
             // Whitespace around the matching ID is permitted so long as it is matched within a valid cgroup line.
             // parse a container ID with leading and trailing whitespace

libdd-common/src/lib.rs

@@ -135,6 +135,40 @@ impl<T> RwLockExt<T> for RwLock<T> {
     }
 }
 
+/// Extension trait that extracts the value from a `Result` whose error type is uninhabited.
+///
+/// The signature constrains callers at compile time: the method is only available when the
+/// error type is [`core::convert::Infallible`]. No panics — the compiler proves the `Err`
+/// arm unreachable from the type.
+///
+/// # Examples
+///
+/// ```
+/// use libdd_common::ResultInfallibleExt;
+/// use std::convert::Infallible;
+///
+/// let result: Result<i32, Infallible> = Ok(42);
+/// assert_eq!(result.unwrap_infallible(), 42);
+/// ```
+pub trait ResultInfallibleExt<T>: sealed::Sealed {
+    fn unwrap_infallible(self) -> T;
+}
+
+impl<T> ResultInfallibleExt<T> for Result<T, core::convert::Infallible> {
+    #[inline(always)]
+    fn unwrap_infallible(self) -> T {
+        match self {
+            Ok(value) => value,
+            Err(never) => match never {},
+        }
+    }
+}
+
+mod sealed {
+    pub trait Sealed {}
+    impl<T> Sealed for Result<T, core::convert::Infallible> {}
+}
+
 pub mod header {
     #![allow(clippy::declare_interior_mutable_const)]
     use http::{header::HeaderName, HeaderValue};

libdd-common/tests/cgroup.pcf

@@ -0,0 +1,12 @@
+12:rdma:/
+11:net_cls,net_prio:/garden/6f265890-5165-7fab-6b52-18d1
+10:freezer:/garden/6f265890-5165-7fab-6b52-18d1
+9:devices:/system.slice/garden.service/garden/6f265890-5165-7fab-6b52-18d1
+8:blkio:/system.slice/garden.service/garden/6f265890-5165-7fab-6b52-18d1
+7:pids:/system.slice/garden.service/garden/6f265890-5165-7fab-6b52-18d1
+6:memory:/system.slice/garden.service/garden/6f265890-5165-7fab-6b52-18d1
+5:cpuset:/garden/6f265890-5165-7fab-6b52-18d1
+4:cpu,cpuacct:/system.slice/garden.service/garden/6f265890-5165-7fab-6b52-18d1
+3:perf_event:/garden/6f265890-5165-7fab-6b52-18d1
+2:hugetlb:/garden/6f265890-5165-7fab-6b52-18d1
+1:name=systemd:/system.slice/garden.service/garden/6f265890-5165-7fab-6b52-18d1

libdd-crashtracker/src/receiver/receive_report.rs

@@ -4,7 +4,7 @@
 use crate::{
     crash_info::{
         CrashInfo, CrashInfoBuilder, ErrorKind, SigInfo, Span, StackFrame, TelemetryCrashUploader,
-        Threads, Ucontext,
+        Ucontext,
     },
     runtime_callback::RuntimeStack,
     shared::constants::*,
@@ -560,7 +560,7 @@ fn collect_and_add_thread_contexts(
     crashing_tid: Option<u32>,
     budget: Duration,
 ) -> anyhow::Result<()> {
-    use crate::crash_info::ThreadData;
+    use crate::crash_info::{ThreadData, Threads};
     use crate::receiver::ptrace_collector::stream_thread_contexts;
 
     let crashing_tid = crashing_tid.unwrap_or(0) as i32;

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

@@ -17,7 +17,7 @@ use libdd_trace_utils::msgpack_encoder;
 use libdd_trace_utils::span::{v04::Span, TraceData};
 use libdd_trace_utils::trace_utils::{self, TracerHeaderTags};
 use libdd_trace_utils::tracer_metadata::TracerMetadata;
-use libdd_trace_utils::tracer_payload;
+use libdd_trace_utils::tracer_payload::{self, TraceEncoding};
 
 /// Minimal capacity of fresh buffers allocated to encode traces, in bytes.
 const MIN_BUFFER_CAPACITY: usize = 1024;
@@ -76,9 +76,13 @@ impl TraceSerializer {
     ) -> Result<tracer_payload::TraceChunks<T>, TraceExporterError> {
         match self.output_format {
             TraceExporterOutputFormat::V1 => Ok(tracer_payload::TraceChunks::V1(traces)),
-            format => {
-                let use_v05_format = matches!(format, TraceExporterOutputFormat::V05);
-                trace_utils::collect_trace_chunks(traces, use_v05_format).map_err(|e| {
+            TraceExporterOutputFormat::V04 => {
+                trace_utils::collect_trace_chunks(traces, TraceEncoding::V04).map_err(|e| {
+                    TraceExporterError::Deserialization(DecodeError::InvalidFormat(e.to_string()))
+                })
+            }
+            TraceExporterOutputFormat::V05 => {
+                trace_utils::collect_trace_chunks(traces, TraceEncoding::V05).map_err(|e| {
                     TraceExporterError::Deserialization(DecodeError::InvalidFormat(e.to_string()))
                 })
             }

libdd-trace-utils/src/msgpack_encoder/mod.rs

@@ -4,6 +4,21 @@
 pub mod v04;
 pub mod v1;
 
+use rmp::encode::ValueWriteError;
+use std::convert::Infallible;
+
+/// Flatten `ValueWriteError<Infallible>` (uninhabited because both variants wrap
+/// `Infallible`) into the bare `Infallible` so callers can use
+/// [`libdd_common::ResultInfallibleExt`].
+#[inline(always)]
+pub(crate) fn flatten_value_write_infallible(err: ValueWriteError<Infallible>) -> Infallible {
+    match err {
+        ValueWriteError::InvalidMarkerWrite(never) | ValueWriteError::InvalidDataWrite(never) => {
+            never
+        }
+    }
+}
+
 /// A writer that counts bytes without storing them, used to compute encoded payload size.
 pub(crate) struct CountLength(u32);
 

libdd-trace-utils/src/msgpack_encoder/v04/mod.rs

@@ -3,6 +3,7 @@
 
 use crate::span::v04::Span;
 use crate::span::TraceData;
+use libdd_common::ResultInfallibleExt;
 use rmp::encode::{write_array_len, ByteBuf, RmpWrite, ValueWriteError};
 
 mod span;
@@ -123,8 +124,9 @@ pub fn to_vec_with_capacity<T: TraceData, S: AsRef<[Span<T>]>>(
     capacity: u32,
 ) -> Vec<u8> {
     let mut buf = ByteBuf::with_capacity(capacity as usize);
-    #[allow(clippy::expect_used)]
-    to_writer(&mut buf, traces).expect("infallible: the error is std::convert::Infallible");
+    to_writer(&mut buf, traces)
+        .map_err(super::flatten_value_write_infallible)
+        .unwrap_infallible();
     buf.into_vec()
 }
 
@@ -158,7 +160,11 @@ pub fn to_vec_with_capacity<T: TraceData, S: AsRef<[Span<T>]>>(
 /// ```
 pub fn to_encoded_byte_len<T: TraceData, S: AsRef<[Span<T>]>>(traces: &[S]) -> u32 {
     let mut counter = super::CountLength(0);
-    #[allow(clippy::expect_used)]
-    to_writer(&mut counter, traces).expect("infallible: CountLength never fails");
+    // `CountLength` impls `std::io::Write` (whose error type is `std::io::Error`, not
+    // `Infallible`), so we can't statically prove infallibility via `unwrap_infallible`
+    // the way we do for `ByteBuf`. In practice `CountLength::write*` only ever return
+    // `Ok`, so the error path here is unreachable today; should `CountLength` ever grow
+    // a fallible code path, fuzz tests on the msgpack encoded length would catch it.
+    let _ = to_writer(&mut counter, traces);
     counter.0
 }

libdd-trace-utils/src/msgpack_encoder/v1/mod.rs

@@ -6,6 +6,7 @@ mod span_v04;
 use crate::span::v04::Span;
 use crate::span::TraceData;
 use crate::tracer_metadata::TracerMetadata;
+use libdd_common::ResultInfallibleExt;
 use rmp::encode::{
     write_array_len, write_bin, write_map_len, write_sint, write_str, write_uint, write_uint8,
     ByteBuf, RmpWrite, ValueWriteError,
@@ -399,7 +400,9 @@ pub fn to_vec_with_capacity<T: TraceData, S: AsRef<[Span<T>]>>(
     metadata: &TracerMetadata,
 ) -> Vec<u8> {
     let mut buf = ByteBuf::with_capacity(capacity as usize);
-    let _ = encode_payload(&mut buf, traces, metadata); // infallible: ByteBuf write never fails
+    encode_payload(&mut buf, traces, metadata)
+        .map_err(super::flatten_value_write_infallible)
+        .unwrap_infallible();
     buf.into_vec()
 }
 
@@ -409,7 +412,12 @@ pub fn to_encoded_byte_len<T: TraceData, S: AsRef<[Span<T>]>>(
     metadata: &TracerMetadata,
 ) -> u32 {
     let mut counter = super::CountLength(0);
-    let _ = encode_payload(&mut counter, traces, metadata); // infallible: CountLength write never fails
+    // `CountLength` impls `std::io::Write` (whose error type is `std::io::Error`, not
+    // `Infallible`), so we can't statically prove infallibility via `unwrap_infallible`
+    // the way we do for `ByteBuf`. In practice `CountLength::write*` only ever return
+    // `Ok`, so the error path here is unreachable today; should `CountLength` ever grow
+    // a fallible code path, fuzz tests on the msgpack encoded length would catch it.
+    let _ = encode_payload(&mut counter, traces, metadata);
     counter.0
 }