test(antithesis): floor buffer size, multi-value packed metrics

Sample dogstatsd_buffer_size mostly >=128 so a tiny buffer does not silently
zero delivery. Emit multi-value :-packed metrics ~5% with a Sometimes anchor.
Rename the send-success anchor to 'workload sent a dogstatsd line'.

Author: blt

test/antithesis/harness/src/bin/first_sample_config/config.rs

@@ -163,13 +163,25 @@ pub(crate) struct DogStatsdConfig {
     dogstatsd_stats_enable: bool,
 }
 
+/// Receive-buffer size in bytes. Mostly realistic so delivery actually happens,
+/// rarely tiny or wild so the truncation edge still gets probed. A sampled `0`
+/// gives ADP a 4-byte buffer that silently drops every line and vacuously
+/// satisfies the delivery anchors, so keep `0` and sub-128 values rare.
+fn sample_buffer_size<R: Rng + ?Sized>(rng: &mut R) -> u64 {
+    if rng.random_ratio(1, 16) {
+        Probe.sample(rng)
+    } else {
+        rng.random_range(128..=65_536)
+    }
+}
+
 impl DogStatsdConfig {
     /// Sample the `DogStatsD` options from `rng`, taking the socket from the
     /// environment.
     fn sample<R: Rng + ?Sized>(rng: &mut R, dogstatsd_socket: &Path) -> Self {
         Self {
             dogstatsd_socket: dogstatsd_socket.to_path_buf(),
-            dogstatsd_buffer_size: Probe.sample(rng),
+            dogstatsd_buffer_size: sample_buffer_size(rng),
             dogstatsd_so_rcvbuf: Probe.sample(rng),
             dogstatsd_packet_buffer_size: Probe.sample(rng),
             dogstatsd_packet_buffer_flush_timeout: Probe.sample(rng),

test/antithesis/harness/src/bin/parallel_driver_send_dogstatsd.rs

@@ -58,18 +58,22 @@ fn main() -> anyhow::Result<()> {
 
     let producer = thread::spawn(move || {
         let mut rng = UnwrapErr(AntithesisRng);
+        let mut multi_value = false;
         for _ in 0..count {
             let vibe = match batch {
                 Batch::Clean => dogstatsd::Vibe::Clean,
                 Batch::Feral => dogstatsd::Vibe::Feral,
                 Batch::Mixed => dogstatsd::sample_vibe(),
             };
             let mut line = Vec::new();
-            dogstatsd::send(&mut rng, &mut line, vibe);
+            if dogstatsd::send(&mut rng, &mut line, vibe) {
+                multi_value = true;
+            }
             if tx.send(line).is_err() {
                 break;
             }
         }
+        multi_value
     });
 
     let consumer = thread::spawn(move || {
@@ -82,7 +86,7 @@ fn main() -> anyhow::Result<()> {
         attempted
     });
 
-    producer.join().expect("producer thread panicked");
+    let multi_value = producer.join().expect("producer thread panicked");
     let attempted = consumer.join().expect("consumer thread panicked");
 
     assert_reachable!(
@@ -91,7 +95,12 @@ fn main() -> anyhow::Result<()> {
     );
     assert_sometimes!(
         attempted > 0,
-        "workload delivered a dogstatsd line",
+        "workload sent a dogstatsd line",
+        &json!({ "attempted": attempted })
+    );
+    assert_sometimes!(
+        multi_value,
+        "workload emitted a multi-value metric",
         &json!({ "attempted": attempted })
     );
     assert_sometimes!(

test/antithesis/harness/src/payload/dogstatsd.rs

@@ -101,11 +101,18 @@ fn choose_message<R: Rng + ?Sized>(rng: &mut R) -> Message {
 }
 
 /// Write one `DogStatsD` message of a sampled type to `buf` at the given vibe.
-pub fn send<R: Rng + ?Sized>(rng: &mut R, buf: &mut Vec<u8>, vibe: Vibe) {
+/// Returns true when a multi-value packed metric was emitted.
+pub fn send<R: Rng + ?Sized>(rng: &mut R, buf: &mut Vec<u8>, vibe: Vibe) -> bool {
     buf.clear();
     match choose_message(rng) {
-        Message::Event => events::write(rng, buf, vibe),
-        Message::ServiceCheck => service_checks::write(rng, buf, vibe),
+        Message::Event => {
+            events::write(rng, buf, vibe);
+            false
+        }
+        Message::ServiceCheck => {
+            service_checks::write(rng, buf, vibe);
+            false
+        }
         Message::Metric => metrics::write(rng, buf, vibe),
     }
 }

test/antithesis/harness/src/payload/dogstatsd/metrics.rs

@@ -2,7 +2,7 @@
 
 use antithesis_sdk::random::random_choice;
 use rand::distr::Distribution;
-use rand::Rng;
+use rand::{Rng, RngExt};
 
 use super::common::{self, Vibe};
 use crate::rand::{Boundary, Wide};
@@ -49,24 +49,41 @@ enum Ext {
     Cardinality,
 }
 
-/// Append one metric line `<NAME>:<VALUE>|<TYPE>[|ext...]` to `buf`.
-pub(crate) fn write<R: Rng + ?Sized>(rng: &mut R, buf: &mut Vec<u8>, vibe: Vibe) {
+/// Append one metric line `<NAME>:<VALUE>|<TYPE>[|ext...]` to `buf`. Returns
+/// true when the value was multi-value packed.
+pub(crate) fn write<R: Rng + ?Sized>(rng: &mut R, buf: &mut Vec<u8>, vibe: Vibe) -> bool {
     common::write_words(rng, buf, vibe);
     buf.push(b':');
-    write_value(rng, buf, vibe);
+    let packed = write_value(rng, buf, vibe);
     buf.push(b'|');
     if let Some(&t) = random_choice(METRIC_TYPES) {
         buf.extend_from_slice(t);
     }
     common::write_tags(rng, buf, vibe);
     write_extensions(rng, buf, vibe);
     buf.push(b'\n');
+    packed
 }
 
 /// Clean: a wide log-uniform value. Feral: an aberrant literal, a wide integer,
 /// or a wide float in a compact or cursed-but-equivalent expanded encoding.
-fn write_value<R: Rng + ?Sized>(rng: &mut R, buf: &mut Vec<u8>, vibe: Vibe) {
+/// ~5% of the time emits a multi-value `:`-packed run, which returns true.
+fn write_value<R: Rng + ?Sized>(rng: &mut R, buf: &mut Vec<u8>, vibe: Vibe) -> bool {
     let mut ryu = ryu::Buffer::new();
+
+    // Multi-value packed: `v1:v2:...`, the codec's colon-split path. Low rate.
+    if rng.random_range(0..20u8) == 0 {
+        let extra = rng.random_range(1..=4u8);
+        for i in 0..=extra {
+            if i > 0 {
+                buf.push(b':');
+            }
+            let v: f64 = Wide.sample(rng);
+            buf.extend_from_slice(ryu.format(v).as_bytes());
+        }
+        return true;
+    }
+
     match vibe {
         Vibe::Clean => {
             let v: f64 = Wide.sample(rng);
@@ -89,6 +106,7 @@ fn write_value<R: Rng + ?Sized>(rng: &mut R, buf: &mut Vec<u8>, vibe: Vibe) {
             }
         },
     }
+    false
 }
 
 /// A boundary-sampled count of extension fields, each a random kind. Repeats and