From fe9c6b5c85781e89bff6d79e8c24443f3c84d4b3 Mon Sep 17 00:00:00 2001
From: Nick Carton <nick@firaenix.me>
Date: Thu, 2 Apr 2026 22:17:36 +0200
Subject: [PATCH 1/4] Add remote write support

---
 Cargo.lock          | 421 +++++++++++++++++++++++++++++++++++++++-
 Cargo.toml          |   3 +
 src/config.rs       |  30 +++
 src/main.rs         |  43 ++++-
 src/remote_write.rs | 457 ++++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 939 insertions(+), 15 deletions(-)
 create mode 100644 src/remote_write.rs

diff --git a/Cargo.lock b/Cargo.lock
index 7be63a7..6e5c696 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -44,6 +44,21 @@ version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
 
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
+
 [[package]]
 name = "approx"
 version = "0.5.1"
@@ -182,6 +197,12 @@ dependencies = [
  "shlex",
 ]
 
+[[package]]
+name = "cesu8"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
+
 [[package]]
 name = "cfg-if"
 version = "1.0.4"
@@ -200,7 +221,11 @@ version = "0.4.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
 dependencies = [
+ "iana-time-zone",
+ "js-sys",
  "num-traits",
+ "wasm-bindgen",
+ "windows-link",
 ]
 
 [[package]]
@@ -239,6 +264,16 @@ dependencies = [
  "tracing-error",
 ]
 
+[[package]]
+name = "combine"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
+dependencies = [
+ "bytes",
+ "memchr",
+]
+
 [[package]]
 name = "core-foundation"
 version = "0.10.1"
@@ -314,6 +349,7 @@ dependencies = [
 name = "distributed-metrics"
 version = "1.1.0"
 dependencies = [
+ "chrono",
  "color-eyre",
  "eyre",
  "figment",
@@ -326,8 +362,10 @@ dependencies = [
  "metrics-util 0.20.1",
  "poem",
  "progenitor",
+ "prometheus-parse",
+ "prometheus-reqwest-remote-write",
  "regress",
- "reqwest",
+ "reqwest 0.12.28",
  "serde",
  "serde_json",
  "serde_regex",
@@ -350,6 +388,12 @@ version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
 
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
 [[package]]
 name = "endian-type"
 version = "0.1.2"
@@ -774,6 +818,30 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "iana-time-zone"
+version = "0.1.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "icu_collections"
 version = "2.2.0"
@@ -935,12 +1003,74 @@ dependencies = [
  "iso_country",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
+[[package]]
+name = "jni"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97"
+dependencies = [
+ "cesu8",
+ "cfg-if",
+ "combine",
+ "jni-sys 0.3.1",
+ "log",
+ "thiserror 1.0.69",
+ "walkdir",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258"
+dependencies = [
+ "jni-sys 0.4.1",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2"
+dependencies = [
+ "jni-sys-macros",
+]
+
+[[package]]
+name = "jni-sys-macros"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264"
+dependencies = [
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "jobserver"
 version = "0.1.34"
@@ -1068,7 +1198,7 @@ dependencies = [
  "metrics-util 0.16.3",
  "parking_lot",
  "poem",
- "prometheus",
+ "prometheus 0.13.4",
  "rust-embed",
  "serde",
 ]
@@ -1104,7 +1234,7 @@ dependencies = [
  "metrics 0.22.4",
  "metrics-util 0.16.3",
  "once_cell",
- "prometheus",
+ "prometheus 0.13.4",
  "sealed",
  "smallvec",
  "thiserror 1.0.69",
@@ -1475,7 +1605,7 @@ dependencies = [
  "bytes",
  "futures-core",
  "percent-encoding",
- "reqwest",
+ "reqwest 0.12.28",
  "serde",
  "serde_json",
  "serde_urlencoded",
@@ -1532,16 +1662,98 @@ dependencies = [
  "lazy_static",
  "memchr",
  "parking_lot",
- "protobuf",
+ "protobuf 2.28.0",
  "thiserror 1.0.69",
 ]
 
+[[package]]
+name = "prometheus"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ca5326d8d0b950a9acd87e6a3f94745394f62e4dae1b1ee22b2bc0c394af43a"
+dependencies = [
+ "cfg-if",
+ "fnv",
+ "lazy_static",
+ "memchr",
+ "parking_lot",
+ "protobuf 3.7.2",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "prometheus-parse"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "811031bea65e5a401fb2e1f37d802cca6601e204ac463809a3189352d13b78a5"
+dependencies = [
+ "chrono",
+ "itertools 0.12.1",
+ "once_cell",
+ "regex",
+]
+
+[[package]]
+name = "prometheus-reqwest-remote-write"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "441b28c02014ba0e458838548d5fe770fd0238f024d250f5512cf8540ab48b7a"
+dependencies = [
+ "prometheus 0.14.0",
+ "prost",
+ "reqwest 0.13.2",
+ "snap",
+]
+
+[[package]]
+name = "prost"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2ea70524a2f82d518bce41317d0fae74151505651af45faf1ffbd6fd33f0568"
+dependencies = [
+ "bytes",
+ "prost-derive",
+]
+
+[[package]]
+name = "prost-derive"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27c6023962132f4b30eb4c172c91ce92d933da334c59c23cddee82358ddafb0b"
+dependencies = [
+ "anyhow",
+ "itertools 0.14.0",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "protobuf"
 version = "2.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "106dd99e98437432fed6519dedecfade6a06a73bb7b2a1e019fdd2bee5778d94"
 
+[[package]]
+name = "protobuf"
+version = "3.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d65a1d4ddae7d8b5de68153b48f6aa3bba8cb002b243dbdbc55a5afbc98f99f4"
+dependencies = [
+ "once_cell",
+ "protobuf-support",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "protobuf-support"
+version = "3.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e36c2f31e0a47f9280fb347ef5e461ffcd2c52dd520d8e216b52f93b0b0d7d6"
+dependencies = [
+ "thiserror 1.0.69",
+]
+
 [[package]]
 name = "quanta"
 version = "0.12.6"
@@ -1583,6 +1795,7 @@ version = "0.11.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "434b42fec591c96ef50e21e886936e66d3cc3f737104fdb9b737c40ffb94c098"
 dependencies = [
+ "aws-lc-rs",
  "bytes",
  "getrandom 0.3.4",
  "lru-slab",
@@ -1773,6 +1986,43 @@ dependencies = [
  "webpki-roots",
 ]
 
+[[package]]
+name = "reqwest"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab3f43e3283ab1488b624b44b0e988d0acea0b3214e694730a055cb6b2efa801"
+dependencies = [
+ "base64",
+ "bytes",
+ "futures-core",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-rustls",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "percent-encoding",
+ "pin-project-lite",
+ "quinn",
+ "rustls",
+ "rustls-pki-types",
+ "rustls-platform-verifier",
+ "serde",
+ "serde_json",
+ "sync_wrapper",
+ "tokio",
+ "tokio-rustls",
+ "tower",
+ "tower-http",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
 [[package]]
 name = "rfc7239"
 version = "0.1.3"
@@ -1889,6 +2139,33 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "rustls-platform-verifier"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784"
+dependencies = [
+ "core-foundation",
+ "core-foundation-sys",
+ "jni",
+ "log",
+ "once_cell",
+ "rustls",
+ "rustls-native-certs",
+ "rustls-platform-verifier-android",
+ "rustls-webpki",
+ "security-framework",
+ "security-framework-sys",
+ "webpki-root-certs",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustls-platform-verifier-android"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
+
 [[package]]
 name = "rustls-webpki"
 version = "0.103.10"
@@ -2189,6 +2466,12 @@ version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
+[[package]]
+name = "snap"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b6b67fb9a61334225b5b790716f609cd58395f895b3fe8b328786812a40bc3b"
+
 [[package]]
 name = "socket2"
 version = "0.6.3"
@@ -2838,6 +3121,15 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "webpki-root-certs"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "804f18a4ac2676ffb4e8b5b5fa9ae38af06df08162314f96a68d2a363e21a8ca"
+dependencies = [
+ "rustls-pki-types",
+]
+
 [[package]]
 name = "webpki-roots"
 version = "1.0.6"
@@ -2884,12 +3176,74 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "windows-link"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+dependencies = [
+ "windows-targets 0.42.2",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
@@ -2917,6 +3271,21 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "windows-targets"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+dependencies = [
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.52.6"
@@ -2950,6 +3319,12 @@ dependencies = [
  "windows_x86_64_msvc 0.53.1",
 ]
 
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.6"
@@ -2962,6 +3337,12 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
@@ -2974,6 +3355,12 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
@@ -2998,6 +3385,12 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
@@ -3010,6 +3403,12 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
@@ -3022,6 +3421,12 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
 
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
@@ -3034,6 +3439,12 @@ version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
 
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
diff --git a/Cargo.toml b/Cargo.toml
index 3b75c32..ef0def0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -40,6 +40,9 @@ humantime-serde = "1.1.1"
 serde_regex = "1.1.0"
 thiserror = "2.0.9"
 geohash = "0.13.1"
+prometheus-reqwest-remote-write = "0.5"
+prometheus-parse = "0.2"
+chrono = "0.4"
 
 # The profile that 'dist' will build with
 [profile.dist]
diff --git a/src/config.rs b/src/config.rs
index 69df8b8..4ac7429 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -25,12 +25,42 @@ pub struct GlobalConfig {
     #[serde(with = "humantime_serde")]
     #[serde(default = "default_metric_clear_timeout")]
     pub metric_clear_timeout: Duration,
+
+    /// Enable the /metrics scrape endpoint (default: true)
+    #[serde(default = "default_true")]
+    pub scrape_enabled: bool,
+
+    /// Remote write destinations
+    #[serde(default)]
+    pub remote_write: Vec<RemoteWriteDestination>,
 }
 
 fn default_metric_clear_timeout() -> Duration {
     Duration::from_secs(10)
 }
 
+fn default_true() -> bool {
+    true
+}
+
+fn default_remote_write_interval() -> Duration {
+    Duration::from_secs(15)
+}
+
+#[derive(Deserialize, Clone, Debug)]
+pub struct RemoteWriteDestination {
+    pub name: String,
+    pub url: String,
+    pub username: Option<String>,
+    pub password: Option<String>,
+    /// Custom HTTP headers (e.g., bearer tokens, API keys).
+    #[serde(default)]
+    pub headers: HashMap<String, String>,
+    #[serde(with = "humantime_serde")]
+    #[serde(default = "default_remote_write_interval")]
+    pub interval: Duration,
+}
+
 #[derive(Deserialize, AsRefStr, Clone, Debug)]
 #[serde(rename_all = "snake_case")]
 #[serde(tag = "type")]
diff --git a/src/main.rs b/src/main.rs
index 82f6228..c5af8a4 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,12 +12,12 @@ use poem::EndpointExt;
 use poem::{get, handler, listener::TcpListener, Route, Server};
 use progenitor::generate_api;
 use std::sync::LazyLock;
-use tokio::join;
 use tokio::task::JoinSet;
 use tracing::{error, info};
 
 mod collectors;
 mod config;
+mod remote_write;
 
 generate_api!(spec = "./api-spec.json", interface = Builder);
 
@@ -81,20 +81,43 @@ async fn main() -> Result<()> {
         .install_recorder()
         .expect("failed to install recorder");
 
-    let app = Route::new()
-        .at("/metrics", get(render_prom))
-        .with(AddData::new(handle));
-
-    let http_server = Server::new(TcpListener::bind("[::]:3000")).run(app);
-
     // Start collection tasks
     let mut join_set = JoinSet::new();
 
-    spawn_collectors(&CONFIG, &mut join_set).await?;
+    // Conditionally start the /metrics scrape endpoint
+    if CONFIG.global_config.scrape_enabled {
+        let scrape_handle = handle.clone();
+        let app = Route::new()
+            .at("/metrics", get(render_prom))
+            .with(AddData::new(scrape_handle));
+        join_set.spawn(async move {
+            if let Err(e) = Server::new(TcpListener::bind("[::]:3000"))
+                .run(app)
+                .await
+            {
+                error!("HTTP server failed: {}", e);
+                std::process::exit(1);
+            }
+        });
+        info!("Scrape endpoint enabled on :3000/metrics");
+    }
+
+    // Start remote write senders
+    if !CONFIG.global_config.remote_write.is_empty() {
+        let sender = remote_write::RemoteWriteSender::new(
+            CONFIG.global_config.remote_write.clone(),
+            handle.clone(),
+        );
+        sender.spawn_all(&mut join_set);
+        info!(
+            count = CONFIG.global_config.remote_write.len(),
+            "Remote write destinations started"
+        );
+    }
 
-    let (rs, _) = join!(http_server, join_set.join_all());
+    spawn_collectors(&CONFIG, &mut join_set).await?;
 
-    rs?;
+    join_set.join_all().await;
 
     Ok(())
 }
diff --git a/src/remote_write.rs b/src/remote_write.rs
new file mode 100644
index 0000000..e9e0d2a
--- /dev/null
+++ b/src/remote_write.rs
@@ -0,0 +1,457 @@
+use std::io::BufRead;
+
+use crate::config::RemoteWriteDestination;
+use eyre::Result;
+use metrics_exporter_prometheus::PrometheusHandle;
+use prometheus_reqwest_remote_write::{
+    Label, Sample as RwSample, TimeSeries, WriteRequest, LABEL_NAME,
+};
+use tokio::task::JoinSet;
+use std::time::Duration;
+use tracing::{debug, info, warn};
+
+pub struct RemoteWriteSender {
+    destinations: Vec<RemoteWriteDestination>,
+    handle: PrometheusHandle,
+    client: reqwest::Client,
+}
+
+impl RemoteWriteSender {
+    pub fn new(destinations: Vec<RemoteWriteDestination>, handle: PrometheusHandle) -> Self {
+        Self {
+            destinations,
+            handle,
+            client: reqwest::Client::new(),
+        }
+    }
+
+    pub fn spawn_all(self, join_set: &mut JoinSet<()>) {
+        for dest in self.destinations {
+            let handle = self.handle.clone();
+            let client = self.client.clone();
+            join_set.spawn(async move {
+                Self::push_loop(dest, handle, client).await;
+            });
+        }
+    }
+
+    async fn push_loop(
+        dest: RemoteWriteDestination,
+        handle: PrometheusHandle,
+        client: reqwest::Client,
+    ) {
+        let base_interval = dest.interval;
+        let mut consecutive_failures: u32 = 0;
+
+        loop {
+            let backoff = if consecutive_failures > 0 {
+                // Exponential backoff: base * 2^failures, capped at 5 minutes
+                let multiplier = 2u64.saturating_pow(consecutive_failures.min(8));
+                let backoff = base_interval.saturating_mul(multiplier as u32);
+                backoff.min(Duration::from_secs(300))
+            } else {
+                base_interval
+            };
+
+            tokio::time::sleep(backoff).await;
+
+            let text = {
+                let h = handle.clone();
+                tokio::task::spawn_blocking(move || h.render())
+                    .await
+                    .unwrap()
+            };
+
+            if text.is_empty() {
+                debug!(dest = %dest.name, "no metrics to push");
+                continue;
+            }
+
+            match Self::push_once(&dest, &client, &text).await {
+                Ok(()) => {
+                    if consecutive_failures > 0 {
+                        info!(dest = %dest.name, "remote_write push recovered after {} failures", consecutive_failures);
+                    }
+                    consecutive_failures = 0;
+                    debug!(dest = %dest.name, "remote_write push succeeded");
+                }
+                Err(e) => {
+                    consecutive_failures = consecutive_failures.saturating_add(1);
+                    let next_multiplier = 2u64.saturating_pow(consecutive_failures.min(8));
+                    let next_backoff = base_interval
+                        .saturating_mul(next_multiplier as u32)
+                        .min(Duration::from_secs(300));
+                    warn!(
+                        dest = %dest.name,
+                        error = %e,
+                        consecutive_failures,
+                        next_retry_secs = next_backoff.as_secs(),
+                        "remote_write push failed"
+                    );
+                }
+            }
+        }
+    }
+
+    async fn push_once(
+        dest: &RemoteWriteDestination,
+        client: &reqwest::Client,
+        text: &str,
+    ) -> Result<()> {
+        let write_request = parse_text_to_write_request(text)?;
+        let body = write_request
+            .encode_compressed()
+            .map_err(|e| eyre::eyre!("snappy compression failed: {}", e))?;
+
+        let mut req = client
+            .post(&dest.url)
+            .header("Content-Type", "application/x-protobuf")
+            .header("Content-Encoding", "snappy")
+            .header("X-Prometheus-Remote-Write-Version", "0.1.0")
+            .body(body);
+
+        for (key, value) in &dest.headers {
+            req = req.header(key, value);
+        }
+
+        if let Some(ref username) = dest.username {
+            req = req.basic_auth(username, dest.password.as_deref());
+        }
+
+        let resp = req.send().await?;
+
+        if !resp.status().is_success() {
+            let status = resp.status();
+            let mut body = resp.text().await.unwrap_or_default();
+            body.truncate(1024);
+            return Err(eyre::eyre!("remote_write returned {}: {}", status, body));
+        }
+        Ok(())
+    }
+}
+
+fn parse_text_to_write_request(text: &str) -> Result<WriteRequest> {
+    let reader = std::io::BufReader::new(text.as_bytes());
+    let scrape = prometheus_parse::Scrape::parse(reader.lines())
+        .map_err(|e| eyre::eyre!("failed to parse prometheus text: {}", e))?;
+
+    let now_ms = chrono::Utc::now().timestamp_millis();
+
+    let mut timeseries: Vec<TimeSeries> = Vec::new();
+
+    for sample in &scrape.samples {
+        let base_labels: Vec<Label> = sample
+            .labels
+            .iter()
+            .map(|(k, v)| Label {
+                name: k.clone(),
+                value: v.clone(),
+            })
+            .collect();
+
+        match &sample.value {
+            prometheus_parse::Value::Counter(v)
+            | prometheus_parse::Value::Gauge(v)
+            | prometheus_parse::Value::Untyped(v) => {
+                let mut labels = vec![Label {
+                    name: LABEL_NAME.to_string(),
+                    value: sample.metric.clone(),
+                }];
+                labels.extend(base_labels);
+                timeseries.push(TimeSeries {
+                    labels,
+                    samples: vec![RwSample {
+                        value: *v,
+                        timestamp: now_ms,
+                    }],
+                });
+            }
+            prometheus_parse::Value::Histogram(counts) => {
+                // Emit each bucket as metric_name_bucket{le="..."}
+                for bucket in counts {
+                    let mut labels = vec![
+                        Label {
+                            name: LABEL_NAME.to_string(),
+                            value: format!("{}_bucket", sample.metric),
+                        },
+                        Label {
+                            name: "le".to_string(),
+                            value: format_le(bucket.less_than),
+                        },
+                    ];
+                    labels.extend(base_labels.clone());
+                    timeseries.push(TimeSeries {
+                        labels,
+                        samples: vec![RwSample {
+                            value: bucket.count,
+                            timestamp: now_ms,
+                        }],
+                    });
+                }
+            }
+            prometheus_parse::Value::Summary(counts) => {
+                // Emit each quantile as metric_name{quantile="..."}
+                for quantile in counts {
+                    let mut labels = vec![
+                        Label {
+                            name: LABEL_NAME.to_string(),
+                            value: sample.metric.clone(),
+                        },
+                        Label {
+                            name: "quantile".to_string(),
+                            value: quantile.quantile.to_string(),
+                        },
+                    ];
+                    labels.extend(base_labels.clone());
+                    timeseries.push(TimeSeries {
+                        labels,
+                        samples: vec![RwSample {
+                            value: quantile.count,
+                            timestamp: now_ms,
+                        }],
+                    });
+                }
+            }
+        }
+    }
+
+    Ok(WriteRequest { timeseries }.sorted())
+}
+
+/// Format the `le` label value for histogram buckets, matching Prometheus conventions.
+fn format_le(value: f64) -> String {
+    if value.is_infinite() {
+        "+Inf".to_string()
+    } else if value.fract() == 0.0 && value.abs() < 1e15 {
+        // Prometheus uses integer formatting when possible (e.g. "1" not "1.0")
+        format!("{}", value as i64)
+    } else {
+        value.to_string()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_gauge() {
+        let text = "# TYPE my_gauge gauge\nmy_gauge{foo=\"bar\"} 42.0\n";
+        let wr = parse_text_to_write_request(text).unwrap();
+        assert_eq!(wr.timeseries.len(), 1);
+
+        let ts = &wr.timeseries[0];
+        assert!(ts.labels.iter().any(|l| l.name == "__name__" && l.value == "my_gauge"));
+        assert!(ts.labels.iter().any(|l| l.name == "foo" && l.value == "bar"));
+        assert_eq!(ts.samples[0].value, 42.0);
+    }
+
+    #[test]
+    fn test_parse_counter() {
+        let text = "# TYPE http_requests_total counter\nhttp_requests_total{method=\"GET\"} 100\n";
+        let wr = parse_text_to_write_request(text).unwrap();
+        assert_eq!(wr.timeseries.len(), 1);
+        assert_eq!(wr.timeseries[0].samples[0].value, 100.0);
+    }
+
+    #[test]
+    fn test_parse_empty() {
+        let wr = parse_text_to_write_request("").unwrap();
+        assert!(wr.timeseries.is_empty());
+    }
+
+    #[test]
+    fn test_parse_multiple_metrics() {
+        let text = "\
+# TYPE a gauge
+a 1
+# TYPE b gauge
+b 2
+# TYPE c gauge
+c 3
+";
+        let wr = parse_text_to_write_request(text).unwrap();
+        assert_eq!(wr.timeseries.len(), 3);
+    }
+
+
+    #[test]
+    fn test_parse_histogram_buckets() {
+        let text = "\
+# HELP h A histogram
+# TYPE h histogram
+h_bucket{le=\"0.1\"} 10
+h_bucket{le=\"0.5\"} 20
+h_bucket{le=\"+Inf\"} 30
+h_sum 42.5
+h_count 30
+";
+        let wr = parse_text_to_write_request(text).unwrap();
+        // 3 buckets + h_sum + h_count = 5 timeseries
+        assert_eq!(wr.timeseries.len(), 5);
+
+        // Check that bucket timeseries have the right __name__ and le labels
+        let buckets: Vec<_> = wr
+            .timeseries
+            .iter()
+            .filter(|ts| {
+                ts.labels
+                    .iter()
+                    .any(|l| l.name == "__name__" && l.value == "h_bucket")
+            })
+            .collect();
+        assert_eq!(buckets.len(), 3);
+
+        // Check le labels exist
+        for ts in &buckets {
+            assert!(ts.labels.iter().any(|l| l.name == "le"));
+        }
+
+        // Check _sum and _count are present
+        assert!(wr.timeseries.iter().any(|ts| ts
+            .labels
+            .iter()
+            .any(|l| l.name == "__name__" && l.value == "h_sum")));
+        assert!(wr.timeseries.iter().any(|ts| ts
+            .labels
+            .iter()
+            .any(|l| l.name == "__name__" && l.value == "h_count")));
+    }
+
+    #[test]
+    fn test_histogram_le_values() {
+        let text = "\
+# TYPE h histogram
+h_bucket{le=\"0.1\"} 1
+h_bucket{le=\"0.5\"} 2
+h_bucket{le=\"1\"} 3
+h_bucket{le=\"10\"} 4
+h_bucket{le=\"+Inf\"} 5
+h_sum 7.5
+h_count 5
+";
+        let wr = parse_text_to_write_request(text).unwrap();
+
+        let buckets: Vec<_> = wr
+            .timeseries
+            .iter()
+            .filter(|ts| {
+                ts.labels
+                    .iter()
+                    .any(|l| l.name == "__name__" && l.value == "h_bucket")
+            })
+            .collect();
+
+        let le_values: Vec<&str> = buckets
+            .iter()
+            .map(|ts| {
+                ts.labels
+                    .iter()
+                    .find(|l| l.name == "le")
+                    .unwrap()
+                    .value
+                    .as_str()
+            })
+            .collect();
+
+        assert!(le_values.contains(&"0.1"));
+        assert!(le_values.contains(&"0.5"));
+        assert!(le_values.contains(&"1"));
+        assert!(le_values.contains(&"10"));
+        assert!(le_values.contains(&"+Inf"));
+    }
+
+    #[test]
+    fn test_format_le_helper() {
+        assert_eq!(format_le(f64::INFINITY), "+Inf");
+        assert_eq!(format_le(0.1), "0.1");
+        assert_eq!(format_le(0.5), "0.5");
+        assert_eq!(format_le(1.0), "1");
+        assert_eq!(format_le(10.0), "10");
+        assert_eq!(format_le(100.0), "100");
+        assert_eq!(format_le(0.001), "0.001");
+    }
+
+    #[test]
+    fn test_labels_preserved_on_histogram() {
+        let text = "\
+# TYPE req histogram
+req_bucket{method=\"GET\",le=\"1\"} 10
+req_bucket{method=\"GET\",le=\"+Inf\"} 15
+req_sum{method=\"GET\"} 8.0
+req_count{method=\"GET\"} 15
+";
+        let wr = parse_text_to_write_request(text).unwrap();
+        // 2 buckets + sum + count = 4
+        assert_eq!(wr.timeseries.len(), 4);
+
+        // Every timeseries should carry the method="GET" label
+        // (except _sum and _count come through as Untyped with labels already set)
+        let buckets: Vec<_> = wr
+            .timeseries
+            .iter()
+            .filter(|ts| {
+                ts.labels
+                    .iter()
+                    .any(|l| l.name == "__name__" && l.value == "req_bucket")
+            })
+            .collect();
+        for ts in &buckets {
+            assert!(
+                ts.labels
+                    .iter()
+                    .any(|l| l.name == "method" && l.value == "GET"),
+                "bucket missing method label: {:?}",
+                ts.labels
+            );
+        }
+    }
+
+    #[test]
+    fn test_counter_with_multiple_labels() {
+        let text = "\
+# TYPE http_requests_total counter
+http_requests_total{method=\"POST\",status=\"200\",path=\"/api\"} 42
+";
+        let wr = parse_text_to_write_request(text).unwrap();
+        assert_eq!(wr.timeseries.len(), 1);
+
+        let ts = &wr.timeseries[0];
+        assert!(ts.labels.iter().any(|l| l.name == "__name__" && l.value == "http_requests_total"));
+        assert!(ts.labels.iter().any(|l| l.name == "method" && l.value == "POST"));
+        assert!(ts.labels.iter().any(|l| l.name == "status" && l.value == "200"));
+        assert!(ts.labels.iter().any(|l| l.name == "path" && l.value == "/api"));
+        assert_eq!(ts.samples[0].value, 42.0);
+    }
+
+    #[test]
+    fn test_timestamps_are_set() {
+        let text = "# TYPE g gauge\ng 1\n";
+        let wr = parse_text_to_write_request(text).unwrap();
+        let ts = &wr.timeseries[0];
+        // Timestamp should be a reasonable epoch ms (after 2020)
+        assert!(ts.samples[0].timestamp > 1_577_836_800_000);
+    }
+
+    #[test]
+    fn test_encode_compressed_roundtrip() {
+        let text = "# TYPE g gauge\ng{host=\"a\"} 1\n# TYPE c counter\nc 99\n";
+        let wr = parse_text_to_write_request(text).unwrap();
+        // Should not panic or error
+        let compressed = wr.encode_compressed();
+        assert!(compressed.is_ok());
+        assert!(!compressed.unwrap().is_empty());
+    }
+
+    #[test]
+    fn test_labels_sorted_by_name() {
+        let text = "# TYPE m gauge\nm{z=\"1\",a=\"2\",m=\"3\"} 1\n";
+        let wr = parse_text_to_write_request(text).unwrap();
+        let ts = &wr.timeseries[0];
+        let names: Vec<&str> = ts.labels.iter().map(|l| l.name.as_str()).collect();
+        // After .sorted(), labels should be alphabetically ordered
+        let mut sorted_names = names.clone();
+        sorted_names.sort();
+        assert_eq!(names, sorted_names, "labels should be sorted by name");
+    }
+}

From 69deed8ff30f1c449194f85bcfe1d40c408b9b50 Mon Sep 17 00:00:00 2001
From: Nick Carton <nick@firaenix.me>
Date: Fri, 3 Apr 2026 11:08:53 +0200
Subject: [PATCH 2/4] Testcontainers tests

---
 AGENTS.md                             |   5 +
 CLAUDE.md                             |   4 +
 Cargo.lock                            | 866 +++++++++++++++++++++++++-
 Cargo.toml                            |   3 +
 src/collectors/dns/mod.rs             |   2 +-
 src/collectors/hls.rs                 |   2 +-
 src/collectors/http.rs                |   2 +-
 src/collectors/icmp.rs                |   2 +-
 src/config.rs                         |   2 -
 src/lib.rs                            |   2 +
 src/main.rs                           |   6 +-
 src/remote_write.rs                   |   5 +-
 tests/remote_write/main.rs            | 122 ++++
 tests/remote_write/prometheus.rs      | 144 +++++
 tests/remote_write/victoriametrics.rs | 149 +++++
 15 files changed, 1282 insertions(+), 34 deletions(-)
 create mode 100644 AGENTS.md
 create mode 100644 src/lib.rs
 create mode 100644 tests/remote_write/main.rs
 create mode 100644 tests/remote_write/prometheus.rs
 create mode 100644 tests/remote_write/victoriametrics.rs

diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..c625fc6
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,5 @@
+# AGENTS.md
+
+## Rules
+
+- No unwraps allowed
diff --git a/CLAUDE.md b/CLAUDE.md
index e21178e..d29b9fb 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -18,3 +18,7 @@ cargo watch -x run   # Hot-reload during development (inside dev shell)
 When `Cargo.toml` changes (version bump or dependency changes):
 - Update `version` in `flake.nix` to match `Cargo.toml`
 - Set `cargoHash` to `""` and rebuild to get the new hash from the error output, then update it
+
+## Rules
+
+- No unwraps allowed
diff --git a/Cargo.lock b/Cargo.lock
index 6e5c696..ea3cdd5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -77,6 +77,44 @@ dependencies = [
  "rustversion",
 ]
 
+[[package]]
+name = "astral-tokio-tar"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c23f3af104b40a3430ccb90ed5f7bd877a8dc5c26fc92fde51a22b40890dcf9"
+dependencies = [
+ "filetime",
+ "futures-core",
+ "libc",
+ "portable-atomic",
+ "rustc-hash",
+ "tokio",
+ "tokio-stream",
+ "xattr",
+]
+
+[[package]]
+name = "async-stream"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b5a71a6f37880a80d1d7f19efd781e4b5de42c88f0722cc13bcb6cc2cfe8476"
+dependencies = [
+ "async-stream-impl",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-stream-impl"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "async-trait"
 version = "0.1.89"
@@ -131,6 +169,49 @@ dependencies = [
  "fs_extra",
 ]
 
+[[package]]
+name = "axum"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b52af3cb4058c895d37317bb27508dccc8e5f2d39454016b297bf4a400597b8"
+dependencies = [
+ "axum-core",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "itoa",
+ "matchit",
+ "memchr",
+ "mime",
+ "percent-encoding",
+ "pin-project-lite",
+ "serde_core",
+ "sync_wrapper",
+ "tower",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "axum-core"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08c78f31d7b1291f7ee735c1c6780ccde7785daae9a9206026862dab7d8792d1"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "http",
+ "http-body",
+ "http-body-util",
+ "mime",
+ "pin-project-lite",
+ "sync_wrapper",
+ "tower-layer",
+ "tower-service",
+]
+
 [[package]]
 name = "backtrace"
 version = "0.3.76"
@@ -146,6 +227,12 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "base64"
+version = "0.21.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+
 [[package]]
 name = "base64"
 version = "0.22.1"
@@ -167,6 +254,80 @@ dependencies = [
  "generic-array",
 ]
 
+[[package]]
+name = "bollard"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee04c4c84f1f811b017f2fbb7dd8815c976e7ca98593de9c1e2afad0f636bff4"
+dependencies = [
+ "async-stream",
+ "base64 0.22.1",
+ "bitflags",
+ "bollard-buildkit-proto",
+ "bollard-stubs",
+ "bytes",
+ "futures-core",
+ "futures-util",
+ "hex",
+ "home",
+ "http",
+ "http-body-util",
+ "hyper",
+ "hyper-named-pipe",
+ "hyper-rustls",
+ "hyper-util",
+ "hyperlocal",
+ "log",
+ "num",
+ "pin-project-lite",
+ "rand",
+ "rustls",
+ "rustls-native-certs",
+ "rustls-pki-types",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "serde_urlencoded",
+ "thiserror 2.0.18",
+ "time",
+ "tokio",
+ "tokio-stream",
+ "tokio-util",
+ "tonic",
+ "tower-service",
+ "url",
+ "winapi",
+]
+
+[[package]]
+name = "bollard-buildkit-proto"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85a885520bf6249ab931a764ffdb87b0ceef48e6e7d807cfdb21b751e086e1ad"
+dependencies = [
+ "prost",
+ "prost-types",
+ "tonic",
+ "tonic-prost",
+ "ureq",
+]
+
+[[package]]
+name = "bollard-stubs"
+version = "1.52.1-rc.29.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f0a8ca8799131c1837d1282c3f81f31e76ceb0ce426e04a7fe1ccee3287c066"
+dependencies = [
+ "base64 0.22.1",
+ "bollard-buildkit-proto",
+ "bytes",
+ "prost",
+ "serde",
+ "serde_json",
+ "serde_repr",
+ "time",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.20.2"
@@ -224,6 +385,7 @@ dependencies = [
  "iana-time-zone",
  "js-sys",
  "num-traits",
+ "serde",
  "wasm-bindgen",
  "windows-link",
 ]
@@ -324,6 +486,50 @@ dependencies = [
  "typenum",
 ]
 
+[[package]]
+name = "darling"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25ae13da2f202d56bd7f91c25fba009e7717a1e4a1cc98a76d844b65ae912e9d"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0"
+dependencies = [
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "deranged"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
+dependencies = [
+ "powerfmt",
+ "serde_core",
+]
+
 [[package]]
 name = "digest"
 version = "0.10.7"
@@ -370,12 +576,24 @@ dependencies = [
  "serde_json",
  "serde_regex",
  "strum",
+ "testcontainers",
  "thiserror 2.0.18",
  "tokio",
  "tracing",
  "tracing-subscriber",
 ]
 
+[[package]]
+name = "docker_credential"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d89dfcba45b4afad7450a99b39e751590463e45c04728cf555d36bb66940de8"
+dependencies = [
+ "base64 0.21.7",
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "dunce"
 version = "1.0.5"
@@ -394,6 +612,15 @@ version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 
+[[package]]
+name = "encoding_rs"
+version = "0.8.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
+dependencies = [
+ "cfg-if",
+]
+
 [[package]]
 name = "endian-type"
 version = "0.1.2"
@@ -416,6 +643,16 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "etcetera"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de48cc4d1c1d97a20fd819def54b890cadde72ed3ad0c614822a0a433361be96"
+dependencies = [
+ "cfg-if",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "eyre"
 version = "0.6.12"
@@ -426,6 +663,17 @@ dependencies = [
  "once_cell",
 ]
 
+[[package]]
+name = "ferroid"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb330bbd4cb7a5b9f559427f06f98a4f853a137c8298f3bd3f8ca57663e21986"
+dependencies = [
+ "portable-atomic",
+ "rand",
+ "web-time",
+]
+
 [[package]]
 name = "figment"
 version = "0.10.19"
@@ -441,6 +689,17 @@ dependencies = [
  "version_check",
 ]
 
+[[package]]
+name = "filetime"
+version = "0.2.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f98844151eee8917efc50bd9e8318cb963ae8b297431495d3f758616ea5c57db"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "libredox",
+]
+
 [[package]]
 name = "find-msvc-tools"
 version = "0.1.9"
@@ -474,6 +733,21 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
 
+[[package]]
+name = "futures"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
 [[package]]
 name = "futures-channel"
 version = "0.3.32"
@@ -481,6 +755,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
 dependencies = [
  "futures-core",
+ "futures-sink",
 ]
 
 [[package]]
@@ -489,6 +764,17 @@ version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
 
+[[package]]
+name = "futures-executor"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
 [[package]]
 name = "futures-io"
 version = "0.3.32"
@@ -524,6 +810,7 @@ version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
 dependencies = [
+ "futures-channel",
  "futures-core",
  "futures-io",
  "futures-macro",
@@ -610,13 +897,19 @@ dependencies = [
  "futures-core",
  "futures-sink",
  "http",
- "indexmap",
+ "indexmap 2.13.0",
  "slab",
  "tokio",
  "tokio-util",
  "tracing",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
 [[package]]
 name = "hashbrown"
 version = "0.13.2"
@@ -652,7 +945,7 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b3314d5adb5d94bcdf56771f2e50dbbc80bb4bdf88967526706205ac9eff24eb"
 dependencies = [
- "base64",
+ "base64 0.22.1",
  "bytes",
  "headers-core",
  "http",
@@ -694,6 +987,15 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
+[[package]]
+name = "home"
+version = "0.5.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc627f471c528ff0c4a49e1d5e60450c8f6461dd6d10ba9dcd3a61d3dff7728d"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "http"
 version = "1.4.0"
@@ -777,6 +1079,21 @@ dependencies = [
  "want",
 ]
 
+[[package]]
+name = "hyper-named-pipe"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73b7d8abf35697b81a825e386fc151e0d503e8cb5fcb93cc8669c376dfd6f278"
+dependencies = [
+ "hex",
+ "hyper",
+ "hyper-util",
+ "pin-project-lite",
+ "tokio",
+ "tower-service",
+ "winapi",
+]
+
 [[package]]
 name = "hyper-rustls"
 version = "0.27.7"
@@ -795,13 +1112,26 @@ dependencies = [
  "webpki-roots",
 ]
 
+[[package]]
+name = "hyper-timeout"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b90d566bffbce6a75bd8b09a05aa8c2cb1fabb6cb348f8840c9e4c90a0d83b0"
+dependencies = [
+ "hyper",
+ "hyper-util",
+ "pin-project-lite",
+ "tokio",
+ "tower-service",
+]
+
 [[package]]
 name = "hyper-util"
 version = "0.1.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0"
 dependencies = [
- "base64",
+ "base64 0.22.1",
  "bytes",
  "futures-channel",
  "futures-util",
@@ -818,6 +1148,21 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "hyperlocal"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "986c5ce3b994526b3cd75578e62554abd09f0899d6206de48b3e96ab34ccc8c7"
+dependencies = [
+ "hex",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "pin-project-lite",
+ "tokio",
+ "tower-service",
+]
+
 [[package]]
 name = "iana-time-zone"
 version = "0.1.65"
@@ -924,6 +1269,12 @@ dependencies = [
  "zerovec",
 ]
 
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
 [[package]]
 name = "idna"
 version = "1.1.0"
@@ -951,6 +1302,17 @@ version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "964de6e86d545b246d84badc0fef527924ace5134f30641c203ef52ba83f58d5"
 
+[[package]]
+name = "indexmap"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+dependencies = [
+ "autocfg",
+ "hashbrown 0.12.3",
+ "serde",
+]
+
 [[package]]
 name = "indexmap"
 version = "2.13.0"
@@ -1124,6 +1486,24 @@ version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
 
+[[package]]
+name = "libredox"
+version = "0.1.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ddbf48fd451246b1f8c2610bd3b4ac0cc6e149d89832867093ab69a17194f08"
+dependencies = [
+ "bitflags",
+ "libc",
+ "plain",
+ "redox_syscall 0.7.3",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
 [[package]]
 name = "litemap"
 version = "0.8.2"
@@ -1160,6 +1540,12 @@ dependencies = [
  "regex-automata",
 ]
 
+[[package]]
+name = "matchit"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"
+
 [[package]]
 name = "memchr"
 version = "2.8.0"
@@ -1209,12 +1595,12 @@ version = "0.17.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b166dea96003ee2531cf14833efedced545751d800f03535801d833313f8c15"
 dependencies = [
- "base64",
+ "base64 0.22.1",
  "http-body-util",
  "hyper",
  "hyper-rustls",
  "hyper-util",
- "indexmap",
+ "indexmap 2.13.0",
  "ipnet",
  "metrics 0.24.3",
  "metrics-util 0.20.1",
@@ -1250,7 +1636,7 @@ dependencies = [
  "crossbeam-epoch",
  "crossbeam-utils",
  "hashbrown 0.14.5",
- "indexmap",
+ "indexmap 2.13.0",
  "metrics 0.22.4",
  "num_cpus",
  "ordered-float 4.6.0",
@@ -1269,7 +1655,7 @@ dependencies = [
  "crossbeam-epoch",
  "crossbeam-utils",
  "hashbrown 0.16.1",
- "indexmap",
+ "indexmap 2.13.0",
  "metrics 0.24.3",
  "ordered-float 5.3.0",
  "quanta",
@@ -1340,9 +1726,79 @@ dependencies = [
 name = "nu-ansi-term"
 version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
+checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "num"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23"
+dependencies = [
+ "num-bigint",
+ "num-complex",
+ "num-integer",
+ "num-iter",
+ "num-rational",
+ "num-traits",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-conv"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6673768db2d862beb9b39a78fdcb1a69439615d5794a1be50caa9bc92c81967"
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-iter"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
 dependencies = [
- "windows-sys 0.61.2",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
 ]
 
 [[package]]
@@ -1386,7 +1842,7 @@ version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5c8d427828b22ae1fff2833a03d8486c2c881367f1c336349f307f321e7f4d05"
 dependencies = [
- "indexmap",
+ "indexmap 2.13.0",
  "serde",
  "serde_json",
 ]
@@ -1439,11 +1895,36 @@ checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
 dependencies = [
  "cfg-if",
  "libc",
- "redox_syscall",
+ "redox_syscall 0.5.18",
  "smallvec",
  "windows-link",
 ]
 
+[[package]]
+name = "parse-display"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "914a1c2265c98e2446911282c6ac86d8524f495792c38c5bd884f80499c7538a"
+dependencies = [
+ "parse-display-derive",
+ "regex",
+ "regex-syntax",
+]
+
+[[package]]
+name = "parse-display-derive"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ae7800a4c974efd12df917266338e79a7a74415173caf7e70aa0a0707345281"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "regex",
+ "regex-syntax",
+ "structmeta",
+ "syn",
+]
+
 [[package]]
 name = "pear"
 version = "0.2.9"
@@ -1473,12 +1954,38 @@ version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
+[[package]]
+name = "pin-project"
+version = "1.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1749c7ed4bcaf4c3d0a3efc28538844fb29bcdd7d2b67b2be7e20ba861ff517"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b20ed30f105399776b9c883e68e536ef602a16ae6f596d2c473591d6ad64c6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "pin-project-lite"
 version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
 
+[[package]]
+name = "plain"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
+
 [[package]]
 name = "poem"
 version = "3.1.12"
@@ -1545,6 +2052,12 @@ dependencies = [
  "zerovec",
 ]
 
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
 [[package]]
 name = "ppv-lite86"
 version = "0.2.21"
@@ -1619,12 +2132,12 @@ checksum = "37adc80a94c9cae890e82deeeecc9d8f2a5cb153256caaf1bf0f03611e537214"
 dependencies = [
  "heck 0.5.0",
  "http",
- "indexmap",
+ "indexmap 2.13.0",
  "openapiv3",
  "proc-macro2",
  "quote",
  "regex",
- "schemars",
+ "schemars 0.8.22",
  "serde",
  "serde_json",
  "syn",
@@ -1643,7 +2156,7 @@ dependencies = [
  "proc-macro2",
  "progenitor-impl",
  "quote",
- "schemars",
+ "schemars 0.8.22",
  "serde",
  "serde_json",
  "serde_tokenstream",
@@ -1728,6 +2241,15 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "prost-types"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8991c4cbdb8bc5b11f0b074ffe286c30e523de90fee5ba8132f1399f23cb3dd7"
+dependencies = [
+ "prost",
+]
+
 [[package]]
 name = "protobuf"
 version = "2.28.0"
@@ -1906,6 +2428,35 @@ dependencies = [
  "bitflags",
 ]
 
+[[package]]
+name = "redox_syscall"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce70a74e890531977d37e532c34d45e9055d2409ed08ddba14529471ed0be16"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "ref-cast"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f354300ae66f76f1c85c5f84693f0ce81d747e2c3f21a45fef496d89c960bf7d"
+dependencies = [
+ "ref-cast-impl",
+]
+
+[[package]]
+name = "ref-cast-impl"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "regex"
 version = "1.12.3"
@@ -1951,7 +2502,7 @@ version = "0.12.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147"
 dependencies = [
- "base64",
+ "base64 0.22.1",
  "bytes",
  "futures-core",
  "futures-util",
@@ -1992,9 +2543,11 @@ version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab3f43e3283ab1488b624b44b0e988d0acea0b3214e694730a055cb6b2efa801"
 dependencies = [
- "base64",
+ "base64 0.22.1",
  "bytes",
+ "encoding_rs",
  "futures-core",
+ "h2",
  "http",
  "http-body",
  "http-body-util",
@@ -2003,6 +2556,7 @@ dependencies = [
  "hyper-util",
  "js-sys",
  "log",
+ "mime",
  "percent-encoding",
  "pin-project-lite",
  "quinn",
@@ -2092,6 +2646,19 @@ version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"
 
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "rustls"
 version = "0.23.37"
@@ -2222,6 +2789,30 @@ dependencies = [
  "uuid",
 ]
 
+[[package]]
+name = "schemars"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "schemars"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2b42f36aa1cd011945615b92222f6bf73c599a102a300334cd7f8dbeec726cc"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "schemars_derive"
 version = "0.8.22"
@@ -2349,6 +2940,17 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "serde_repr"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "serde_spanned"
 version = "0.6.9"
@@ -2382,13 +2984,44 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "serde_with"
+version = "3.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd5414fad8e6907dbdd5bc441a50ae8d6e26151a03b1de04d89a5576de61d01f"
+dependencies = [
+ "base64 0.22.1",
+ "chrono",
+ "hex",
+ "indexmap 1.9.3",
+ "indexmap 2.13.0",
+ "schemars 0.9.0",
+ "schemars 1.2.1",
+ "serde_core",
+ "serde_json",
+ "serde_with_macros",
+ "time",
+]
+
+[[package]]
+name = "serde_with_macros"
+version = "3.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3db8978e608f1fe7357e211969fd9abdcae80bac1ba7a3369bb7eb6b404eb65"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "serde_yaml"
 version = "0.9.34+deprecated"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
 dependencies = [
- "indexmap",
+ "indexmap 2.13.0",
  "itoa",
  "ryu",
  "serde",
@@ -2488,6 +3121,35 @@ version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "structmeta"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e1575d8d40908d70f6fd05537266b90ae71b15dbbe7a8b7dffa2b759306d329"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "structmeta-derive",
+ "syn",
+]
+
+[[package]]
+name = "structmeta-derive"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "152a0b65a590ff6c3da95cabe2353ee04e6167c896b28e3b14478c2636c922fc"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "strum"
 version = "0.27.2"
@@ -2546,6 +3208,38 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "testcontainers"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bd36b06a2a6c0c3c81a83be1ab05fe86460d054d4d51bf513bc56b3e15bdc22"
+dependencies = [
+ "astral-tokio-tar",
+ "async-trait",
+ "bollard",
+ "bytes",
+ "docker_credential",
+ "either",
+ "etcetera",
+ "ferroid",
+ "futures",
+ "http",
+ "itertools 0.14.0",
+ "log",
+ "memchr",
+ "parse-display",
+ "pin-project-lite",
+ "reqwest 0.13.2",
+ "serde",
+ "serde_json",
+ "serde_with",
+ "thiserror 2.0.18",
+ "tokio",
+ "tokio-stream",
+ "tokio-util",
+ "url",
+]
+
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@@ -2595,6 +3289,37 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "time"
+version = "0.3.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c"
+dependencies = [
+ "deranged",
+ "itoa",
+ "num-conv",
+ "powerfmt",
+ "serde_core",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"
+
+[[package]]
+name = "time-macros"
+version = "0.2.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
 [[package]]
 name = "tinystr"
 version = "0.8.3"
@@ -2658,6 +3383,17 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "tokio-stream"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32da49809aab5c3bc678af03902d4ccddea2a87d028d86392a4b1560c6906c70"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+ "tokio",
+]
+
 [[package]]
 name = "tokio-util"
 version = "0.7.18"
@@ -2707,7 +3443,7 @@ version = "0.22.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
 dependencies = [
- "indexmap",
+ "indexmap 2.13.0",
  "serde",
  "serde_spanned",
  "toml_datetime 0.6.11",
@@ -2721,7 +3457,7 @@ version = "0.25.10+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a82418ca169e235e6c399a84e395ab6debeb3bc90edc959bf0f48647c6a32d1b"
 dependencies = [
- "indexmap",
+ "indexmap 2.13.0",
  "toml_datetime 1.1.1+spec-1.1.0",
  "toml_parser",
  "winnow 1.0.1",
@@ -2742,6 +3478,46 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
 
+[[package]]
+name = "tonic"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fec7c61a0695dc1887c1b53952990f3ad2e3a31453e1f49f10e75424943a93ec"
+dependencies = [
+ "async-trait",
+ "axum",
+ "base64 0.22.1",
+ "bytes",
+ "h2",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-timeout",
+ "hyper-util",
+ "percent-encoding",
+ "pin-project",
+ "socket2",
+ "sync_wrapper",
+ "tokio",
+ "tokio-stream",
+ "tower",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "tonic-prost"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a55376a0bbaa4975a3f10d009ad763d8f4108f067c7c2e74f3001fb49778d309"
+dependencies = [
+ "bytes",
+ "prost",
+ "tonic",
+]
+
 [[package]]
 name = "tower"
 version = "0.5.3"
@@ -2750,11 +3526,15 @@ checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4"
 dependencies = [
  "futures-core",
  "futures-util",
+ "indexmap 2.13.0",
  "pin-project-lite",
+ "slab",
  "sync_wrapper",
  "tokio",
+ "tokio-util",
  "tower-layer",
  "tower-service",
+ "tracing",
 ]
 
 [[package]]
@@ -2904,7 +3684,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "regress",
- "schemars",
+ "schemars 0.8.22",
  "semver",
  "serde",
  "serde_json",
@@ -2921,7 +3701,7 @@ checksum = "68b5780d745920ed73c5b7447496a9b5c42ed2681a9b70859377aec423ecf02b"
 dependencies = [
  "proc-macro2",
  "quote",
- "schemars",
+ "schemars 0.8.22",
  "semver",
  "serde",
  "serde_json",
@@ -2963,6 +3743,33 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
+[[package]]
+name = "ureq"
+version = "3.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dea7109cdcd5864d4eeb1b58a1648dc9bf520360d7af16ec26d0a9354bafcfc0"
+dependencies = [
+ "base64 0.22.1",
+ "log",
+ "percent-encoding",
+ "rustls",
+ "rustls-pki-types",
+ "ureq-proto",
+ "utf8-zero",
+]
+
+[[package]]
+name = "ureq-proto"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e994ba84b0bd1b1b0cf92878b7ef898a5c1760108fe7b6010327e274917a808c"
+dependencies = [
+ "base64 0.22.1",
+ "http",
+ "httparse",
+ "log",
+]
+
 [[package]]
 name = "url"
 version = "2.5.8"
@@ -2973,8 +3780,15 @@ dependencies = [
  "idna",
  "percent-encoding",
  "serde",
+ "serde_derive",
 ]
 
+[[package]]
+name = "utf8-zero"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8c0a043c9540bae7c578c88f91dda8bd82e59ae27c21baca69c8b191aaf5a6e"
+
 [[package]]
 name = "utf8_iter"
 version = "1.0.4"
@@ -3487,6 +4301,16 @@ version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
 
+[[package]]
+name = "xattr"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156"
+dependencies = [
+ "libc",
+ "rustix",
+]
+
 [[package]]
 name = "yansi"
 version = "1.0.1"
diff --git a/Cargo.toml b/Cargo.toml
index ef0def0..2e83e90 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -44,6 +44,9 @@ prometheus-reqwest-remote-write = "0.5"
 prometheus-parse = "0.2"
 chrono = "0.4"
 
+[dev-dependencies]
+testcontainers = { version = "0.27", features = ["http_wait"] }
+
 # The profile that 'dist' will build with
 [profile.dist]
 inherits = "release"
diff --git a/src/collectors/dns/mod.rs b/src/collectors/dns/mod.rs
index 3c60b66..6a7f68c 100644
--- a/src/collectors/dns/mod.rs
+++ b/src/collectors/dns/mod.rs
@@ -1,7 +1,7 @@
 mod errors;
 
 use super::{Collector, CollectorErrors};
-use crate::config::{DnsConfig, LookupTypes};
+use distributed_metrics::config::{DnsConfig, LookupTypes};
 use crate::types::{
     PerformDnsBodyConfiguration, PerformDnsBodyConfigurationLookupTypesItem,
     PerformDnsBodyContinentCode, PerformDnsBodyCountryCode, PerformDnsBodyMobile,
diff --git a/src/collectors/hls.rs b/src/collectors/hls.rs
index d66e1e9..73120c5 100644
--- a/src/collectors/hls.rs
+++ b/src/collectors/hls.rs
@@ -1,5 +1,5 @@
 use super::{Collector, CollectorErrors};
-use crate::config::HlsConfig;
+use distributed_metrics::config::HlsConfig;
 use crate::types::*;
 use crate::API_CLIENT;
 use color_eyre::eyre::Result;
diff --git a/src/collectors/http.rs b/src/collectors/http.rs
index c7bf8ff..942c6e2 100644
--- a/src/collectors/http.rs
+++ b/src/collectors/http.rs
@@ -1,5 +1,5 @@
 use super::{Collector, CollectorErrors};
-use crate::config::{HttpConfig, LookupTypes};
+use distributed_metrics::config::{HttpConfig, LookupTypes};
 use crate::types::{
     PerformHttpBodyConfiguration, PerformHttpBodyContinentCode, PerformHttpBodyCountryCode,
     PerformHttpBodyMobile, PerformHttpBodyProxy, PerformHttpBodyResidential, PerformHttpResponse,
diff --git a/src/collectors/icmp.rs b/src/collectors/icmp.rs
index 00e1a2e..28fb7d5 100644
--- a/src/collectors/icmp.rs
+++ b/src/collectors/icmp.rs
@@ -1,5 +1,5 @@
 use super::{Collector, CollectorErrors};
-use crate::config::IcmpConfig;
+use distributed_metrics::config::IcmpConfig;
 use crate::types::{
     PerformIcmpBodyContinentCode, PerformIcmpBodyCountryCode, PerformIcmpBodyMobile,
     PerformIcmpBodyProxy, PerformIcmpBodyResidential, PerformIcmpResponse,
diff --git a/src/config.rs b/src/config.rs
index 4ac7429..2c86350 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,6 +1,5 @@
 use std::{collections::HashMap, time::Duration};
 
-use regress::Regex;
 use serde::Deserialize;
 
 use eyre::{Context, Result};
@@ -8,7 +7,6 @@ use figment::{
     providers::{Env, Format, Yaml},
     Figment,
 };
-use serde_json::Value;
 use strum::{AsRefStr, EnumString};
 
 // Configuration structs
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..b103135
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,2 @@
+pub mod config;
+pub mod remote_write;
diff --git a/src/main.rs b/src/main.rs
index c5af8a4..4d56980 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,9 +1,9 @@
-use crate::config::Conf;
 use collectors::http::HttpCollector;
 use collectors::icmp::IcmpCollector;
 use collectors::{dns, hls, Collector};
 use color_eyre::eyre::Result;
-use config::MetricType;
+use distributed_metrics::config::{Conf, MetricType};
+use distributed_metrics::remote_write;
 use metrics_exporter_prometheus::{PrometheusBuilder, PrometheusHandle};
 use metrics_util::MetricKindMask;
 use poem::middleware::AddData;
@@ -16,8 +16,6 @@ use tokio::task::JoinSet;
 use tracing::{error, info};
 
 mod collectors;
-mod config;
-mod remote_write;
 
 generate_api!(spec = "./api-spec.json", interface = Builder);
 
diff --git a/src/remote_write.rs b/src/remote_write.rs
index e9e0d2a..e1a6e76 100644
--- a/src/remote_write.rs
+++ b/src/remote_write.rs
@@ -93,7 +93,7 @@ impl RemoteWriteSender {
         }
     }
 
-    async fn push_once(
+    pub async fn push_once(
         dest: &RemoteWriteDestination,
         client: &reqwest::Client,
         text: &str,
@@ -130,7 +130,7 @@ impl RemoteWriteSender {
     }
 }
 
-fn parse_text_to_write_request(text: &str) -> Result<WriteRequest> {
+pub fn parse_text_to_write_request(text: &str) -> Result<WriteRequest> {
     let reader = std::io::BufReader::new(text.as_bytes());
     let scrape = prometheus_parse::Scrape::parse(reader.lines())
         .map_err(|e| eyre::eyre!("failed to parse prometheus text: {}", e))?;
@@ -274,7 +274,6 @@ c 3
         assert_eq!(wr.timeseries.len(), 3);
     }
 
-
     #[test]
     fn test_parse_histogram_buckets() {
         let text = "\
diff --git a/tests/remote_write/main.rs b/tests/remote_write/main.rs
new file mode 100644
index 0000000..f10ae70
--- /dev/null
+++ b/tests/remote_write/main.rs
@@ -0,0 +1,122 @@
+//! Integration tests: exercise the real remote write code path against both
+//! VictoriaMetrics and Prometheus.
+//!
+//! Flow: metrics crate → PrometheusHandle::render() → RemoteWriteSender::push_once() → backend → query
+//!
+//! Requires Docker/Podman. Run with:
+//!   cargo test --test remote_write -- --ignored
+
+mod prometheus;
+mod victoriametrics;
+
+use std::collections::HashMap;
+
+use distributed_metrics::config::RemoteWriteDestination;
+use distributed_metrics::remote_write::RemoteWriteSender;
+
+// ---------------------------------------------------------------------------
+// Backend abstraction
+// ---------------------------------------------------------------------------
+
+pub struct RemoteWriteBackend {
+    pub base_url: String,
+    pub write_path: String,
+    pub client: reqwest::Client,
+    flush: Box<
+        dyn Fn(
+                &reqwest::Client,
+                &str,
+            ) -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>
+            + Send
+            + Sync,
+    >,
+}
+
+impl RemoteWriteBackend {
+    pub fn make_dest(&self) -> RemoteWriteDestination {
+        RemoteWriteDestination {
+            name: "test".to_string(),
+            url: format!("{}{}", self.base_url, self.write_path),
+            username: None,
+            password: None,
+            headers: HashMap::new(),
+            interval: std::time::Duration::from_secs(15),
+        }
+    }
+
+    /// Push rendered Prometheus text through the real `RemoteWriteSender::push_once` code path.
+    pub async fn push(&self, text: &str) {
+        let dest = self.make_dest();
+        RemoteWriteSender::push_once(&dest, &self.client, text)
+            .await
+            .expect("push_once failed");
+    }
+
+    /// Flush the backend so writes become queryable. See backend-specific implementations
+    /// for details on why this is needed.
+    pub async fn flush(&self) {
+        (self.flush)(&self.client, &self.base_url).await;
+    }
+
+    /// Execute a PromQL instant query and return the result value for the first match.
+    /// Panics if the metric is not found.
+    pub async fn query_value(&self, promql: &str) -> f64 {
+        let result = self.query(promql).await;
+        let results = Self::query_results(&result);
+        assert!(
+            !results.is_empty(),
+            "metric not found for query: {}",
+            promql
+        );
+        results[0]["value"][1]
+            .as_str()
+            .expect("value should be a string")
+            .parse()
+            .expect("value should be a float")
+    }
+
+    /// Execute a PromQL instant query and return the full JSON response.
+    pub async fn query(&self, promql: &str) -> serde_json::Value {
+        let resp = self
+            .client
+            .get(format!("{}/api/v1/query", self.base_url))
+            .query(&[("query", promql)])
+            .send()
+            .await
+            .expect("failed to query backend");
+
+        resp.json::<serde_json::Value>()
+            .await
+            .expect("failed to parse query response")
+    }
+
+    /// Execute a PromQL instant query and return the label map for the first match.
+    /// Panics if the metric is not found.
+    pub async fn query_labels(&self, promql: &str) -> serde_json::Value {
+        let result = self.query(promql).await;
+        let results = Self::query_results(&result);
+        assert!(
+            !results.is_empty(),
+            "metric not found for query: {}",
+            promql
+        );
+        results[0]["metric"].clone()
+    }
+
+    /// Assert that a PromQL query returns at least one result.
+    pub async fn assert_exists(&self, promql: &str) {
+        let result = self.query(promql).await;
+        let results = Self::query_results(&result);
+        assert!(
+            !results.is_empty(),
+            "expected results for query: {}",
+            promql
+        );
+    }
+
+    pub fn query_results(response: &serde_json::Value) -> &Vec<serde_json::Value> {
+        response["data"]["result"]
+            .as_array()
+            .expect("missing data.result in query response")
+    }
+}
diff --git a/tests/remote_write/prometheus.rs b/tests/remote_write/prometheus.rs
new file mode 100644
index 0000000..3e02583
--- /dev/null
+++ b/tests/remote_write/prometheus.rs
@@ -0,0 +1,144 @@
+use super::RemoteWriteBackend;
+use metrics::{counter, gauge, histogram};
+use metrics_exporter_prometheus::PrometheusBuilder;
+use testcontainers::core::ImageExt;
+use testcontainers::{core::IntoContainerPort, runners::AsyncRunner, GenericImage};
+
+async fn start() -> (
+    testcontainers::ContainerAsync<GenericImage>,
+    RemoteWriteBackend,
+) {
+    let container = GenericImage::new("prom/prometheus", "latest")
+        .with_exposed_port(9090.tcp())
+        .with_wait_for(testcontainers::core::WaitFor::seconds(3))
+        .with_cmd([
+            "--config.file=/etc/prometheus/prometheus.yml",
+            "--web.enable-remote-write-receiver",
+            // Reduce TSDB commit interval so writes are queryable faster in tests.
+            "--storage.tsdb.min-block-duration=1s",
+        ])
+        .start()
+        .await
+        .expect("failed to start Prometheus");
+
+    let host = container.get_host().await.expect("failed to get host");
+    let port = container
+        .get_host_port_ipv4(9090.tcp())
+        .await
+        .expect("failed to get port");
+    let base_url = format!("http://{}:{}", host, port);
+
+    let backend = RemoteWriteBackend {
+        base_url,
+        write_path: "/api/v1/write".to_string(),
+        client: reqwest::Client::new(),
+        // Prometheus commits TSDB blocks asynchronously. A short delay after writing
+        // gives the TSDB time to commit the head block so queries return fresh data.
+        flush: Box::new(|_client, _base_url| {
+            Box::pin(async move {
+                tokio::time::sleep(std::time::Duration::from_secs(2)).await;
+            })
+        }),
+    };
+
+    (container, backend)
+}
+
+#[tokio::test]
+#[ignore = "Requires Docker/Podman"]
+async fn gauge_and_counter() {
+    // Arrange
+    let (_container, backend) = start().await;
+    let recorder = PrometheusBuilder::new().build_recorder();
+    let handle = recorder.handle();
+
+    // Act
+    metrics::with_local_recorder(&recorder, || {
+        gauge!("prom_test_gauge", "env" => "test", "host" => "ci").set(42.0);
+        counter!("prom_test_requests_total", "method" => "GET", "status" => "200").increment(17);
+    });
+    backend.push(&handle.render()).await;
+    backend.flush().await;
+
+    // Assert
+    assert_eq!(backend.query_value("prom_test_gauge").await, 42.0);
+    let labels = backend.query_labels("prom_test_gauge").await;
+    assert_eq!(labels["env"], "test");
+    assert_eq!(labels["host"], "ci");
+
+    assert_eq!(
+        backend
+            .query_value(r#"prom_test_requests_total{method="GET"}"#)
+            .await,
+        17.0
+    );
+    let labels = backend
+        .query_labels(r#"prom_test_requests_total{method="GET"}"#)
+        .await;
+    assert_eq!(labels["status"], "200");
+}
+
+#[tokio::test]
+#[ignore = "Requires Docker/Podman"]
+async fn histogram() {
+    // Arrange
+    let (_container, backend) = start().await;
+    let recorder = PrometheusBuilder::new().build_recorder();
+    let handle = recorder.handle();
+    let expected_sum = 0.05 + 0.15 + 0.5 + 1.5 + 5.0;
+
+    // Act
+    metrics::with_local_recorder(&recorder, || {
+        let h = histogram!("prom_test_duration_seconds", "endpoint" => "/api");
+        h.record(0.05);
+        h.record(0.15);
+        h.record(0.5);
+        h.record(1.5);
+        h.record(5.0);
+    });
+    backend.push(&handle.render()).await;
+    backend.flush().await;
+
+    // Assert
+    let sum = backend.query_value("prom_test_duration_seconds_sum").await;
+    assert!(
+        (sum - expected_sum).abs() < 0.001,
+        "expected sum ~{}, got {}",
+        expected_sum,
+        sum
+    );
+    assert_eq!(
+        backend
+            .query_value("prom_test_duration_seconds_count")
+            .await,
+        5.0
+    );
+    let labels = backend
+        .query_labels(r#"prom_test_duration_seconds{quantile="0.5"}"#)
+        .await;
+    assert_eq!(labels["endpoint"], "/api");
+}
+
+#[tokio::test]
+#[ignore = "Requires Docker/Podman"]
+async fn multiple_pushes() {
+    // Arrange
+    let (_container, backend) = start().await;
+    let recorder = PrometheusBuilder::new().build_recorder();
+    let handle = recorder.handle();
+
+    // Act
+    metrics::with_local_recorder(&recorder, || {
+        counter!("prom_test_push_counter").increment(10);
+    });
+    backend.push(&handle.render()).await;
+
+    metrics::with_local_recorder(&recorder, || {
+        counter!("prom_test_push_counter").increment(5);
+    });
+    backend.push(&handle.render()).await;
+    backend.flush().await;
+
+    // Assert
+    assert_eq!(backend.query_value("prom_test_push_counter").await, 15.0);
+}
diff --git a/tests/remote_write/victoriametrics.rs b/tests/remote_write/victoriametrics.rs
new file mode 100644
index 0000000..2d675ef
--- /dev/null
+++ b/tests/remote_write/victoriametrics.rs
@@ -0,0 +1,149 @@
+use super::RemoteWriteBackend;
+use metrics::{counter, gauge, histogram};
+use metrics_exporter_prometheus::PrometheusBuilder;
+use testcontainers::core::ImageExt;
+use testcontainers::{core::IntoContainerPort, runners::AsyncRunner, GenericImage};
+
+async fn start() -> (
+    testcontainers::ContainerAsync<GenericImage>,
+    RemoteWriteBackend,
+) {
+    let container = GenericImage::new("victoriametrics/victoria-metrics", "latest")
+        .with_exposed_port(8428.tcp())
+        .with_wait_for(testcontainers::core::WaitFor::seconds(2))
+        .with_cmd([
+            "-search.latencyOffset=0s",
+            "-search.maxStalenessInterval=0s",
+        ])
+        .start()
+        .await
+        .expect("failed to start VictoriaMetrics");
+
+    let host = container.get_host().await.expect("failed to get host");
+    let port = container
+        .get_host_port_ipv4(8428.tcp())
+        .await
+        .expect("failed to get port");
+    let base_url = format!("http://{}:{}", host, port);
+
+    let backend = RemoteWriteBackend {
+        base_url,
+        write_path: "/api/v1/write".to_string(),
+        client: reqwest::Client::new(),
+        // VictoriaMetrics buffers incoming data and flushes to storage asynchronously.
+        // Without an explicit flush, queries immediately after a write may return empty
+        // results. This calls VM's `/internal/force_flush` endpoint and waits briefly
+        // for indexing to complete. This is a test-only concern — production remote
+        // write clients don't need to flush the receiving end.
+        flush: Box::new(|client, base_url| {
+            let client = client.clone();
+            let base_url = base_url.to_string();
+            Box::pin(async move {
+                let _ = client
+                    .get(format!("{}/internal/force_flush", base_url))
+                    .send()
+                    .await;
+                tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+            })
+        }),
+    };
+
+    (container, backend)
+}
+
+#[tokio::test]
+#[ignore = "Requires Docker/Podman"]
+async fn gauge_and_counter() {
+    // Arrange
+    let (_container, backend) = start().await;
+    let recorder = PrometheusBuilder::new().build_recorder();
+    let handle = recorder.handle();
+
+    // Act
+    metrics::with_local_recorder(&recorder, || {
+        gauge!("vm_test_gauge", "env" => "test", "host" => "ci").set(42.0);
+        counter!("vm_test_requests_total", "method" => "GET", "status" => "200").increment(17);
+    });
+    backend.push(&handle.render()).await;
+    backend.flush().await;
+
+    // Assert
+    assert_eq!(backend.query_value("vm_test_gauge").await, 42.0);
+    let labels = backend.query_labels("vm_test_gauge").await;
+    assert_eq!(labels["env"], "test");
+    assert_eq!(labels["host"], "ci");
+
+    assert_eq!(
+        backend
+            .query_value(r#"vm_test_requests_total{method="GET"}"#)
+            .await,
+        17.0
+    );
+    let labels = backend
+        .query_labels(r#"vm_test_requests_total{method="GET"}"#)
+        .await;
+    assert_eq!(labels["status"], "200");
+}
+
+#[tokio::test]
+#[ignore = "Requires Docker/Podman"]
+async fn histogram() {
+    // Arrange
+    let (_container, backend) = start().await;
+    let recorder = PrometheusBuilder::new().build_recorder();
+    let handle = recorder.handle();
+    let expected_sum = 0.05 + 0.15 + 0.5 + 1.5 + 5.0;
+
+    // Act
+    metrics::with_local_recorder(&recorder, || {
+        let h = histogram!("vm_test_duration_seconds", "endpoint" => "/api");
+        h.record(0.05);
+        h.record(0.15);
+        h.record(0.5);
+        h.record(1.5);
+        h.record(5.0);
+    });
+    backend.push(&handle.render()).await;
+    backend.flush().await;
+
+    // Assert
+    let sum = backend.query_value("vm_test_duration_seconds_sum").await;
+    assert!(
+        (sum - expected_sum).abs() < 0.001,
+        "expected sum ~{}, got {}",
+        expected_sum,
+        sum
+    );
+    assert_eq!(
+        backend.query_value("vm_test_duration_seconds_count").await,
+        5.0
+    );
+    let labels = backend
+        .query_labels(r#"vm_test_duration_seconds{quantile="0.5"}"#)
+        .await;
+    assert_eq!(labels["endpoint"], "/api");
+}
+
+#[tokio::test]
+#[ignore = "Requires Docker/Podman"]
+async fn multiple_pushes() {
+    // Arrange
+    let (_container, backend) = start().await;
+    let recorder = PrometheusBuilder::new().build_recorder();
+    let handle = recorder.handle();
+
+    // Act
+    metrics::with_local_recorder(&recorder, || {
+        counter!("vm_test_push_counter").increment(10);
+    });
+    backend.push(&handle.render()).await;
+
+    metrics::with_local_recorder(&recorder, || {
+        counter!("vm_test_push_counter").increment(5);
+    });
+    backend.push(&handle.render()).await;
+    backend.flush().await;
+
+    // Assert
+    assert_eq!(backend.query_value("vm_test_push_counter").await, 15.0);
+}

From 9cde1983a2b56622a36034d5752b42e63e7a0ce9 Mon Sep 17 00:00:00 2001
From: Nick Carton <nick@firaenix.me>
Date: Fri, 3 Apr 2026 11:12:18 +0200
Subject: [PATCH 3/4] update docs

---
 Metrics.example.yaml | 17 +++++++++++++
 README.md            | 59 +++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 75 insertions(+), 1 deletion(-)

diff --git a/Metrics.example.yaml b/Metrics.example.yaml
index a3aaabe..22ce945 100644
--- a/Metrics.example.yaml
+++ b/Metrics.example.yaml
@@ -1,5 +1,22 @@
 metric_clear_timeout: 1s
 
+# Scrape endpoint (default: true). Set to false if using remote write only.
+# scrape_enabled: false
+
+# Remote write destinations (optional). Push metrics to one or more
+# Prometheus-compatible endpoints instead of (or in addition to) scraping.
+# remote_write:
+#   - name: grafana-cloud
+#     url: https://prometheus-prod-01-eu-west-0.grafana.net/api/prom/push
+#     username: "123456"
+#     password: "glc_xxx..."
+#     interval: 15s
+#   - name: local-victoriametrics
+#     url: http://localhost:8428/api/v1/write
+#     interval: 10s
+#     headers:
+#       X-Custom-Header: "my-value"
+
 metrics:
   - type: dns
     endpoint: jup.ag
diff --git a/README.md b/README.md
index a0eb656..0e8a053 100644
--- a/README.md
+++ b/README.md
@@ -20,7 +20,7 @@ You can also specify the network type of the reporting device such as if its a R
    ```bash
    distributed-metrics
    ```
-Metrics will be available at `http://localhost:3000/metrics` in Prometheus format.
+Metrics will be available at `http://localhost:3000/metrics` in Prometheus format. You can also push metrics to remote endpoints via [remote write](#remote-write).
 
 ## Installation
 
@@ -68,6 +68,22 @@ Run:
 docker compose up -d
 ```
 
+#### Remote write only (no scrape endpoint)
+
+If you only need remote write, you can skip exposing port 3000:
+
+```yaml
+version: '3'
+services:
+  metrics:
+    image: bitping/distributed-metrics
+    environment:
+      - BITPING_API_KEY=your_api_key
+    volumes:
+      - ./Metrics.yaml:/app/Metrics.yaml
+    restart: unless-stopped
+```
+
 ## Supported Protocols
 
 ### DNS
@@ -216,11 +232,52 @@ Labels:
 
 ```yaml
 metric_clear_timeout: 10s # How long to keep metrics after a scrape has occured - prevents timeouts on scraping as cardinality can be high
+scrape_enabled: true       # Enable the /metrics scrape endpoint (default: true)
 
 metrics:
   # Protocol configurations as shown above
 ```
 
+### Remote Write
+
+Push metrics to one or more Prometheus-compatible remote write endpoints (Grafana Cloud, VictoriaMetrics, Mimir, Cortex, Thanos, etc.) instead of or in addition to the scrape endpoint.
+
+```yaml
+remote_write:
+  - name: grafana-cloud
+    url: https://prometheus-prod-01-eu-west-0.grafana.net/api/prom/push
+    username: "123456"
+    password: "glc_your_api_key_here"
+    interval: 15s
+
+  - name: local-victoriametrics
+    url: http://victoriametrics:8428/api/v1/write
+    interval: 10s
+    headers:
+      Authorization: "Bearer my-token"
+```
+
+| Field | Required | Default | Description |
+|-------|----------|---------|-------------|
+| `name` | Yes | — | Identifier for logging |
+| `url` | Yes | — | Remote write endpoint URL |
+| `username` | No | — | Basic auth username |
+| `password` | No | — | Basic auth password |
+| `headers` | No | `{}` | Custom HTTP headers (e.g., bearer tokens) |
+| `interval` | No | `15s` | Push interval |
+
+To disable the scrape endpoint and use only remote write:
+
+```yaml
+scrape_enabled: false
+
+remote_write:
+  - name: my-destination
+    url: https://my-endpoint/api/v1/write
+```
+
+On consecutive push failures, the sender backs off exponentially (base interval * 2^failures, capped at 5 minutes) and resets on success.
+
 ### Network Selection Parameters
 
 All protocols support these network selection criteria:

From dfd5184ed6c4b43de1e7a85ee1fa2c1cc26bd97c Mon Sep 17 00:00:00 2001
From: Nick Carton <nick@firaenix.me>
Date: Fri, 3 Apr 2026 16:04:00 +0200
Subject: [PATCH 4/4] more unit tests, fix unwraps

---
 CLAUDE.md                             |  10 +
 README.md                             |  10 +
 src/config.rs                         |   7 +
 src/remote_write.rs                   | 610 ++++++++++++++++++++------
 tests/remote_write/fault_injection.rs | 500 +++++++++++++++++++++
 tests/remote_write/main.rs            |   2 +
 6 files changed, 995 insertions(+), 144 deletions(-)
 create mode 100644 tests/remote_write/fault_injection.rs

diff --git a/CLAUDE.md b/CLAUDE.md
index d29b9fb..52238de 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -13,6 +13,16 @@ nix run              # Run directly
 cargo watch -x run   # Hot-reload during development (inside dev shell)
 ```
 
+## Testing
+
+```bash
+cargo test                                            # Unit tests only
+cargo test --test remote_write -- --ignored           # Integration tests (requires Docker/Podman)
+cargo test --test remote_write -- --ignored --nocapture # Integration tests with output
+```
+
+Integration tests spin up VictoriaMetrics and Prometheus containers via testcontainers, push metrics through the real `RemoteWriteSender::push_once` code path, and query back to verify correctness. Each test suite runs against both backends.
+
 ## Flake Maintenance
 
 When `Cargo.toml` changes (version bump or dependency changes):
diff --git a/README.md b/README.md
index 0e8a053..a547a02 100644
--- a/README.md
+++ b/README.md
@@ -265,6 +265,7 @@ remote_write:
 | `password` | No | — | Basic auth password |
 | `headers` | No | `{}` | Custom HTTP headers (e.g., bearer tokens) |
 | `interval` | No | `15s` | Push interval |
+| `timeout` | No | `30s` | HTTP request timeout per push |
 
 To disable the scrape endpoint and use only remote write:
 
@@ -300,6 +301,15 @@ All metrics support these base configuration options:
 - `frequency`: How often to collect metrics (e.g., "1s", "15s", "1m")
 - `network`: Network selection criteria (see above)
 
+## Testing
+
+```bash
+cargo test                                            # Unit tests only
+cargo test --test remote_write -- --ignored           # Integration tests (requires Docker/Podman)
+```
+
+Integration tests run the real remote write code path against both VictoriaMetrics and Prometheus containers (via [testcontainers](https://crates.io/crates/testcontainers)). They verify that gauges, counters, and histograms push correctly and are queryable on both backends.
+
 ## Error Handling
 
 All collectors track failures with specific error types in their respective `*_failures_total` or `*_errors_by_type` metrics. Common error categories include:
diff --git a/src/config.rs b/src/config.rs
index 2c86350..118347f 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -45,6 +45,10 @@ fn default_remote_write_interval() -> Duration {
     Duration::from_secs(15)
 }
 
+fn default_remote_write_timeout() -> Duration {
+    Duration::from_secs(30)
+}
+
 #[derive(Deserialize, Clone, Debug)]
 pub struct RemoteWriteDestination {
     pub name: String,
@@ -57,6 +61,9 @@ pub struct RemoteWriteDestination {
     #[serde(with = "humantime_serde")]
     #[serde(default = "default_remote_write_interval")]
     pub interval: Duration,
+    #[serde(with = "humantime_serde")]
+    #[serde(default = "default_remote_write_timeout")]
+    pub timeout: Duration,
 }
 
 #[derive(Deserialize, AsRefStr, Clone, Debug)]
diff --git a/src/remote_write.rs b/src/remote_write.rs
index e1a6e76..65aa673 100644
--- a/src/remote_write.rs
+++ b/src/remote_write.rs
@@ -1,4 +1,5 @@
 use std::io::BufRead;
+use std::time::Duration;
 
 use crate::config::RemoteWriteDestination;
 use eyre::Result;
@@ -7,8 +8,13 @@ use prometheus_reqwest_remote_write::{
     Label, Sample as RwSample, TimeSeries, WriteRequest, LABEL_NAME,
 };
 use tokio::task::JoinSet;
-use std::time::Duration;
-use tracing::{debug, info, warn};
+use tracing::{debug, error, info, warn};
+
+/// Maximum backoff duration between retries (5 minutes).
+const MAX_BACKOFF: Duration = Duration::from_secs(300);
+
+/// Maximum exponent for 2^n to prevent overflow in backoff calculation.
+const MAX_BACKOFF_EXPONENT: u32 = 8;
 
 pub struct RemoteWriteSender {
     destinations: Vec<RemoteWriteDestination>,
@@ -44,22 +50,15 @@ impl RemoteWriteSender {
         let mut consecutive_failures: u32 = 0;
 
         loop {
-            let backoff = if consecutive_failures > 0 {
-                // Exponential backoff: base * 2^failures, capped at 5 minutes
-                let multiplier = 2u64.saturating_pow(consecutive_failures.min(8));
-                let backoff = base_interval.saturating_mul(multiplier as u32);
-                backoff.min(Duration::from_secs(300))
-            } else {
-                base_interval
-            };
-
+            let backoff = calculate_backoff(base_interval, consecutive_failures);
             tokio::time::sleep(backoff).await;
 
-            let text = {
-                let h = handle.clone();
-                tokio::task::spawn_blocking(move || h.render())
-                    .await
-                    .unwrap()
+            let text = match render_metrics(&handle).await {
+                Ok(text) => text,
+                Err(e) => {
+                    error!(dest = %dest.name, error = %e, "failed to render metrics");
+                    continue;
+                }
             };
 
             if text.is_empty() {
@@ -70,17 +69,19 @@ impl RemoteWriteSender {
             match Self::push_once(&dest, &client, &text).await {
                 Ok(()) => {
                     if consecutive_failures > 0 {
-                        info!(dest = %dest.name, "remote_write push recovered after {} failures", consecutive_failures);
+                        info!(
+                            dest = %dest.name,
+                            "remote_write push recovered after {} failures",
+                            consecutive_failures
+                        );
                     }
                     consecutive_failures = 0;
                     debug!(dest = %dest.name, "remote_write push succeeded");
                 }
                 Err(e) => {
                     consecutive_failures = consecutive_failures.saturating_add(1);
-                    let next_multiplier = 2u64.saturating_pow(consecutive_failures.min(8));
-                    let next_backoff = base_interval
-                        .saturating_mul(next_multiplier as u32)
-                        .min(Duration::from_secs(300));
+                    let next_backoff =
+                        calculate_backoff(base_interval, consecutive_failures);
                     warn!(
                         dest = %dest.name,
                         error = %e,
@@ -105,6 +106,7 @@ impl RemoteWriteSender {
 
         let mut req = client
             .post(&dest.url)
+            .timeout(dest.timeout)
             .header("Content-Type", "application/x-protobuf")
             .header("Content-Encoding", "snappy")
             .header("X-Prometheus-Remote-Write-Version", "0.1.0")
@@ -130,6 +132,26 @@ impl RemoteWriteSender {
     }
 }
 
+/// Render metrics from the PrometheusHandle in a blocking task.
+async fn render_metrics(handle: &PrometheusHandle) -> Result<String> {
+    let h = handle.clone();
+    tokio::task::spawn_blocking(move || h.render())
+        .await
+        .map_err(|e| eyre::eyre!("render task panicked: {}", e))
+}
+
+/// Calculate the backoff duration for a given number of consecutive failures.
+/// Uses exponential backoff: base_interval * 2^failures, capped at MAX_BACKOFF.
+/// Returns base_interval when there are no failures.
+pub fn calculate_backoff(base_interval: Duration, consecutive_failures: u32) -> Duration {
+    if consecutive_failures == 0 {
+        return base_interval;
+    }
+    let multiplier = 2u64.saturating_pow(consecutive_failures.min(MAX_BACKOFF_EXPONENT));
+    let backoff = base_interval.saturating_mul(multiplier as u32);
+    backoff.min(MAX_BACKOFF)
+}
+
 pub fn parse_text_to_write_request(text: &str) -> Result<WriteRequest> {
     let reader = std::io::BufReader::new(text.as_bytes());
     let scrape = prometheus_parse::Scrape::parse(reader.lines())
@@ -167,7 +189,6 @@ pub fn parse_text_to_write_request(text: &str) -> Result<WriteRequest> {
                 });
             }
             prometheus_parse::Value::Histogram(counts) => {
-                // Emit each bucket as metric_name_bucket{le="..."}
                 for bucket in counts {
                     let mut labels = vec![
                         Label {
@@ -190,7 +211,6 @@ pub fn parse_text_to_write_request(text: &str) -> Result<WriteRequest> {
                 }
             }
             prometheus_parse::Value::Summary(counts) => {
-                // Emit each quantile as metric_name{quantile="..."}
                 for quantile in counts {
                     let mut labels = vec![
                         Label {
@@ -220,10 +240,11 @@ pub fn parse_text_to_write_request(text: &str) -> Result<WriteRequest> {
 
 /// Format the `le` label value for histogram buckets, matching Prometheus conventions.
 fn format_le(value: f64) -> String {
-    if value.is_infinite() {
+    if value.is_infinite() && value.is_sign_positive() {
         "+Inf".to_string()
+    } else if value.is_infinite() {
+        "-Inf".to_string()
     } else if value.fract() == 0.0 && value.abs() < 1e15 {
-        // Prometheus uses integer formatting when possible (e.g. "1" not "1.0")
         format!("{}", value as i64)
     } else {
         value.to_string()
@@ -234,12 +255,148 @@ fn format_le(value: f64) -> String {
 mod tests {
     use super::*;
 
+    // -----------------------------------------------------------------------
+    // calculate_backoff
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn backoff_zero_failures_returns_base() {
+        // Arrange
+        let base = Duration::from_secs(15);
+
+        // Act
+        let result = calculate_backoff(base, 0);
+
+        // Assert
+        assert_eq!(result, base);
+    }
+
+    #[test]
+    fn backoff_one_failure_doubles() {
+        // Arrange
+        let base = Duration::from_secs(10);
+
+        // Act
+        let result = calculate_backoff(base, 1);
+
+        // Assert
+        assert_eq!(result, Duration::from_secs(20));
+    }
+
+    #[test]
+    fn backoff_three_failures_is_8x() {
+        // Arrange
+        let base = Duration::from_secs(5);
+
+        // Act
+        let result = calculate_backoff(base, 3);
+
+        // Assert
+        assert_eq!(result, Duration::from_secs(40)); // 5 * 2^3 = 40
+    }
+
+    #[test]
+    fn backoff_caps_at_max() {
+        // Arrange
+        let base = Duration::from_secs(15);
+
+        // Act
+        let result = calculate_backoff(base, 100);
+
+        // Assert
+        assert_eq!(result, MAX_BACKOFF);
+    }
+
+    #[test]
+    fn backoff_exponent_capped_at_8() {
+        // Arrange
+        let base = Duration::from_secs(1);
+
+        // Act — failures 8, 9, 10 should all produce the same multiplier (256)
+        let at_8 = calculate_backoff(base, 8);
+        let at_9 = calculate_backoff(base, 9);
+        let at_20 = calculate_backoff(base, 20);
+
+        // Assert
+        assert_eq!(at_8, Duration::from_secs(256));
+        assert_eq!(at_9, Duration::from_secs(256));
+        assert_eq!(at_20, Duration::from_secs(256));
+    }
+
+    #[test]
+    fn backoff_large_base_saturates_to_max() {
+        // Arrange — base of 60s * 256 = 15360s, but capped at 300s
+        let base = Duration::from_secs(60);
+
+        // Act
+        let result = calculate_backoff(base, 8);
+
+        // Assert
+        assert_eq!(result, MAX_BACKOFF);
+    }
+
+    #[test]
+    fn backoff_u32_max_failures_does_not_panic() {
+        // Arrange
+        let base = Duration::from_secs(1);
+
+        // Act — should not overflow or panic
+        let result = calculate_backoff(base, u32::MAX);
+
+        // Assert
+        assert_eq!(result, Duration::from_secs(256).min(MAX_BACKOFF));
+    }
+
+    // -----------------------------------------------------------------------
+    // format_le
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn format_le_infinity() {
+        assert_eq!(format_le(f64::INFINITY), "+Inf");
+    }
+
+    #[test]
+    fn format_le_negative_infinity() {
+        assert_eq!(format_le(f64::NEG_INFINITY), "-Inf");
+    }
+
+    #[test]
+    fn format_le_whole_numbers_as_integers() {
+        assert_eq!(format_le(1.0), "1");
+        assert_eq!(format_le(10.0), "10");
+        assert_eq!(format_le(100.0), "100");
+        assert_eq!(format_le(0.0), "0");
+    }
+
     #[test]
-    fn test_parse_gauge() {
+    fn format_le_fractional_numbers() {
+        assert_eq!(format_le(0.1), "0.1");
+        assert_eq!(format_le(0.5), "0.5");
+        assert_eq!(format_le(0.001), "0.001");
+    }
+
+    #[test]
+    fn format_le_nan() {
+        // NaN should pass through as the float's string representation
+        let result = format_le(f64::NAN);
+        assert_eq!(result, "NaN");
+    }
+
+    // -----------------------------------------------------------------------
+    // parse_text_to_write_request — basic types
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn parse_gauge() {
+        // Arrange
         let text = "# TYPE my_gauge gauge\nmy_gauge{foo=\"bar\"} 42.0\n";
-        let wr = parse_text_to_write_request(text).unwrap();
-        assert_eq!(wr.timeseries.len(), 1);
 
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
+
+        // Assert
+        assert_eq!(wr.timeseries.len(), 1);
         let ts = &wr.timeseries[0];
         assert!(ts.labels.iter().any(|l| l.name == "__name__" && l.value == "my_gauge"));
         assert!(ts.labels.iter().any(|l| l.name == "foo" && l.value == "bar"));
@@ -247,35 +404,64 @@ mod tests {
     }
 
     #[test]
-    fn test_parse_counter() {
+    fn parse_counter() {
+        // Arrange
         let text = "# TYPE http_requests_total counter\nhttp_requests_total{method=\"GET\"} 100\n";
-        let wr = parse_text_to_write_request(text).unwrap();
+
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
+
+        // Assert
         assert_eq!(wr.timeseries.len(), 1);
         assert_eq!(wr.timeseries[0].samples[0].value, 100.0);
     }
 
     #[test]
-    fn test_parse_empty() {
-        let wr = parse_text_to_write_request("").unwrap();
+    fn parse_empty_input() {
+        // Arrange / Act
+        let wr = parse_text_to_write_request("").expect("parse failed");
+
+        // Assert
         assert!(wr.timeseries.is_empty());
     }
 
     #[test]
-    fn test_parse_multiple_metrics() {
-        let text = "\
-# TYPE a gauge
-a 1
-# TYPE b gauge
-b 2
-# TYPE c gauge
-c 3
-";
-        let wr = parse_text_to_write_request(text).unwrap();
+    fn parse_multiple_metrics() {
+        // Arrange
+        let text = "# TYPE a gauge\na 1\n# TYPE b gauge\nb 2\n# TYPE c gauge\nc 3\n";
+
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
+
+        // Assert
         assert_eq!(wr.timeseries.len(), 3);
     }
 
     #[test]
-    fn test_parse_histogram_buckets() {
+    fn parse_counter_with_multiple_labels() {
+        // Arrange
+        let text = "# TYPE http_requests_total counter\nhttp_requests_total{method=\"POST\",status=\"200\",path=\"/api\"} 42\n";
+
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
+
+        // Assert
+        assert_eq!(wr.timeseries.len(), 1);
+        let ts = &wr.timeseries[0];
+        assert!(ts.labels.iter().any(|l| l.name == "__name__" && l.value == "http_requests_total"));
+        assert!(ts.labels.iter().any(|l| l.name == "method" && l.value == "POST"));
+        assert!(ts.labels.iter().any(|l| l.name == "status" && l.value == "200"));
+        assert!(ts.labels.iter().any(|l| l.name == "path" && l.value == "/api"));
+        assert_eq!(ts.samples[0].value, 42.0);
+    }
+
+    // -----------------------------------------------------------------------
+    // parse_text_to_write_request — histograms
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn parse_histogram_emits_buckets_sum_count() {
+        // Arrange
         let text = "\
 # HELP h A histogram
 # TYPE h histogram
@@ -285,40 +471,28 @@ h_bucket{le=\"+Inf\"} 30
 h_sum 42.5
 h_count 30
 ";
-        let wr = parse_text_to_write_request(text).unwrap();
-        // 3 buckets + h_sum + h_count = 5 timeseries
+
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
+
+        // Assert — 3 buckets + h_sum + h_count = 5 timeseries
         assert_eq!(wr.timeseries.len(), 5);
 
-        // Check that bucket timeseries have the right __name__ and le labels
-        let buckets: Vec<_> = wr
-            .timeseries
-            .iter()
-            .filter(|ts| {
-                ts.labels
-                    .iter()
-                    .any(|l| l.name == "__name__" && l.value == "h_bucket")
-            })
+        let buckets: Vec<_> = wr.timeseries.iter()
+            .filter(|ts| ts.labels.iter().any(|l| l.name == "__name__" && l.value == "h_bucket"))
             .collect();
         assert_eq!(buckets.len(), 3);
-
-        // Check le labels exist
         for ts in &buckets {
             assert!(ts.labels.iter().any(|l| l.name == "le"));
         }
 
-        // Check _sum and _count are present
-        assert!(wr.timeseries.iter().any(|ts| ts
-            .labels
-            .iter()
-            .any(|l| l.name == "__name__" && l.value == "h_sum")));
-        assert!(wr.timeseries.iter().any(|ts| ts
-            .labels
-            .iter()
-            .any(|l| l.name == "__name__" && l.value == "h_count")));
+        assert!(wr.timeseries.iter().any(|ts| ts.labels.iter().any(|l| l.name == "__name__" && l.value == "h_sum")));
+        assert!(wr.timeseries.iter().any(|ts| ts.labels.iter().any(|l| l.name == "__name__" && l.value == "h_count")));
     }
 
     #[test]
-    fn test_histogram_le_values() {
+    fn parse_histogram_le_values_correct() {
+        // Arrange
         let text = "\
 # TYPE h histogram
 h_bucket{le=\"0.1\"} 1
@@ -329,30 +503,17 @@ h_bucket{le=\"+Inf\"} 5
 h_sum 7.5
 h_count 5
 ";
-        let wr = parse_text_to_write_request(text).unwrap();
 
-        let buckets: Vec<_> = wr
-            .timeseries
-            .iter()
-            .filter(|ts| {
-                ts.labels
-                    .iter()
-                    .any(|l| l.name == "__name__" && l.value == "h_bucket")
-            })
-            .collect();
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
 
-        let le_values: Vec<&str> = buckets
-            .iter()
-            .map(|ts| {
-                ts.labels
-                    .iter()
-                    .find(|l| l.name == "le")
-                    .unwrap()
-                    .value
-                    .as_str()
-            })
+        // Assert
+        let buckets: Vec<_> = wr.timeseries.iter()
+            .filter(|ts| ts.labels.iter().any(|l| l.name == "__name__" && l.value == "h_bucket"))
+            .collect();
+        let le_values: Vec<&str> = buckets.iter()
+            .filter_map(|ts| ts.labels.iter().find(|l| l.name == "le").map(|l| l.value.as_str()))
             .collect();
-
         assert!(le_values.contains(&"0.1"));
         assert!(le_values.contains(&"0.5"));
         assert!(le_values.contains(&"1"));
@@ -361,18 +522,8 @@ h_count 5
     }
 
     #[test]
-    fn test_format_le_helper() {
-        assert_eq!(format_le(f64::INFINITY), "+Inf");
-        assert_eq!(format_le(0.1), "0.1");
-        assert_eq!(format_le(0.5), "0.5");
-        assert_eq!(format_le(1.0), "1");
-        assert_eq!(format_le(10.0), "10");
-        assert_eq!(format_le(100.0), "100");
-        assert_eq!(format_le(0.001), "0.001");
-    }
-
-    #[test]
-    fn test_labels_preserved_on_histogram() {
+    fn parse_histogram_preserves_extra_labels() {
+        // Arrange
         let text = "\
 # TYPE req histogram
 req_bucket{method=\"GET\",le=\"1\"} 10
@@ -380,77 +531,248 @@ req_bucket{method=\"GET\",le=\"+Inf\"} 15
 req_sum{method=\"GET\"} 8.0
 req_count{method=\"GET\"} 15
 ";
-        let wr = parse_text_to_write_request(text).unwrap();
-        // 2 buckets + sum + count = 4
-        assert_eq!(wr.timeseries.len(), 4);
 
-        // Every timeseries should carry the method="GET" label
-        // (except _sum and _count come through as Untyped with labels already set)
-        let buckets: Vec<_> = wr
-            .timeseries
-            .iter()
-            .filter(|ts| {
-                ts.labels
-                    .iter()
-                    .any(|l| l.name == "__name__" && l.value == "req_bucket")
-            })
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
+
+        // Assert
+        assert_eq!(wr.timeseries.len(), 4);
+        let buckets: Vec<_> = wr.timeseries.iter()
+            .filter(|ts| ts.labels.iter().any(|l| l.name == "__name__" && l.value == "req_bucket"))
             .collect();
         for ts in &buckets {
             assert!(
-                ts.labels
-                    .iter()
-                    .any(|l| l.name == "method" && l.value == "GET"),
-                "bucket missing method label: {:?}",
-                ts.labels
+                ts.labels.iter().any(|l| l.name == "method" && l.value == "GET"),
+                "bucket missing method label: {:?}", ts.labels
             );
         }
     }
 
+    // -----------------------------------------------------------------------
+    // parse_text_to_write_request — edge cases
+    // -----------------------------------------------------------------------
+
     #[test]
-    fn test_counter_with_multiple_labels() {
-        let text = "\
-# TYPE http_requests_total counter
-http_requests_total{method=\"POST\",status=\"200\",path=\"/api\"} 42
-";
-        let wr = parse_text_to_write_request(text).unwrap();
-        assert_eq!(wr.timeseries.len(), 1);
+    fn parse_only_comments_and_help() {
+        // Arrange
+        let text = "# HELP my_metric A helpful metric\n# TYPE my_metric gauge\n";
+
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
+
+        // Assert
+        assert!(wr.timeseries.is_empty());
+    }
+
+    #[test]
+    fn parse_metric_without_labels() {
+        // Arrange
+        let text = "# TYPE up gauge\nup 1\n";
 
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
+
+        // Assert
+        assert_eq!(wr.timeseries.len(), 1);
         let ts = &wr.timeseries[0];
-        assert!(ts.labels.iter().any(|l| l.name == "__name__" && l.value == "http_requests_total"));
-        assert!(ts.labels.iter().any(|l| l.name == "method" && l.value == "POST"));
-        assert!(ts.labels.iter().any(|l| l.name == "status" && l.value == "200"));
-        assert!(ts.labels.iter().any(|l| l.name == "path" && l.value == "/api"));
-        assert_eq!(ts.samples[0].value, 42.0);
+        assert_eq!(ts.labels.len(), 1); // only __name__
+        assert!(ts.labels.iter().any(|l| l.name == "__name__" && l.value == "up"));
     }
 
     #[test]
-    fn test_timestamps_are_set() {
+    fn parse_untyped_metric() {
+        // Arrange — no # TYPE line means Untyped
+        let text = "my_metric 123.456\n";
+
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
+
+        // Assert
+        assert_eq!(wr.timeseries.len(), 1);
+        assert_eq!(wr.timeseries[0].samples[0].value, 123.456);
+    }
+
+    #[test]
+    fn parse_nan_value() {
+        // Arrange
+        let text = "# TYPE g gauge\ng NaN\n";
+
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
+
+        // Assert
+        assert_eq!(wr.timeseries.len(), 1);
+        assert!(wr.timeseries[0].samples[0].value.is_nan());
+    }
+
+    #[test]
+    fn parse_positive_infinity_value() {
+        // Arrange
+        let text = "# TYPE g gauge\ng +Inf\n";
+
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
+
+        // Assert
+        assert_eq!(wr.timeseries.len(), 1);
+        assert!(wr.timeseries[0].samples[0].value.is_infinite());
+        assert!(wr.timeseries[0].samples[0].value.is_sign_positive());
+    }
+
+    #[test]
+    fn parse_negative_infinity_value() {
+        // Arrange
+        let text = "# TYPE g gauge\ng -Inf\n";
+
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
+
+        // Assert
+        assert_eq!(wr.timeseries.len(), 1);
+        assert!(wr.timeseries[0].samples[0].value.is_infinite());
+        assert!(wr.timeseries[0].samples[0].value.is_sign_negative());
+    }
+
+    #[test]
+    fn parse_zero_value() {
+        // Arrange
+        let text = "# TYPE g gauge\ng 0\n";
+
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
+
+        // Assert
+        assert_eq!(wr.timeseries[0].samples[0].value, 0.0);
+    }
+
+    #[test]
+    fn parse_negative_value() {
+        // Arrange
+        let text = "# TYPE g gauge\ng -42.5\n";
+
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
+
+        // Assert
+        assert_eq!(wr.timeseries[0].samples[0].value, -42.5);
+    }
+
+    #[test]
+    fn parse_scientific_notation() {
+        // Arrange
+        let text = "# TYPE g gauge\ng 1.23e4\n";
+
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
+
+        // Assert
+        assert_eq!(wr.timeseries[0].samples[0].value, 12300.0);
+    }
+
+    #[test]
+    fn parse_label_with_special_characters() {
+        // Arrange
+        let text = "# TYPE m gauge\nm{path=\"/api/v1/users\",method=\"GET\"} 1\n";
+
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
+
+        // Assert
+        assert!(wr.timeseries[0].labels.iter().any(|l| l.name == "path" && l.value == "/api/v1/users"));
+    }
+
+    #[test]
+    fn parse_label_with_escaped_quotes() {
+        // Arrange
+        let text = "# TYPE m gauge\nm{msg=\"hello \\\"world\\\"\"} 1\n";
+
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
+
+        // Assert
+        assert_eq!(wr.timeseries.len(), 1);
+    }
+
+    // -----------------------------------------------------------------------
+    // parse_text_to_write_request — output properties
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn timestamps_are_recent() {
+        // Arrange
         let text = "# TYPE g gauge\ng 1\n";
-        let wr = parse_text_to_write_request(text).unwrap();
-        let ts = &wr.timeseries[0];
-        // Timestamp should be a reasonable epoch ms (after 2020)
-        assert!(ts.samples[0].timestamp > 1_577_836_800_000);
+
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
+
+        // Assert — timestamp should be a reasonable epoch ms (after 2020)
+        assert!(wr.timeseries[0].samples[0].timestamp > 1_577_836_800_000);
     }
 
     #[test]
-    fn test_encode_compressed_roundtrip() {
+    fn encode_compressed_produces_nonempty_bytes() {
+        // Arrange
         let text = "# TYPE g gauge\ng{host=\"a\"} 1\n# TYPE c counter\nc 99\n";
-        let wr = parse_text_to_write_request(text).unwrap();
-        // Should not panic or error
+
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
         let compressed = wr.encode_compressed();
+
+        // Assert
         assert!(compressed.is_ok());
-        assert!(!compressed.unwrap().is_empty());
+        assert!(!compressed.expect("encode failed").is_empty());
     }
 
     #[test]
-    fn test_labels_sorted_by_name() {
+    fn labels_are_sorted_by_name() {
+        // Arrange
         let text = "# TYPE m gauge\nm{z=\"1\",a=\"2\",m=\"3\"} 1\n";
-        let wr = parse_text_to_write_request(text).unwrap();
+
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
+
+        // Assert
         let ts = &wr.timeseries[0];
         let names: Vec<&str> = ts.labels.iter().map(|l| l.name.as_str()).collect();
-        // After .sorted(), labels should be alphabetically ordered
-        let mut sorted_names = names.clone();
-        sorted_names.sort();
-        assert_eq!(names, sorted_names, "labels should be sorted by name");
+        let mut sorted = names.clone();
+        sorted.sort();
+        assert_eq!(names, sorted, "labels should be sorted by name");
+    }
+
+    #[test]
+    fn high_cardinality_input() {
+        // Arrange — 100 distinct timeseries
+        let mut text = String::from("# TYPE m gauge\n");
+        for i in 0..100 {
+            text.push_str(&format!("m{{id=\"{}\"}} {}\n", i, i as f64));
+        }
+
+        // Act
+        let wr = parse_text_to_write_request(&text).expect("parse failed");
+
+        // Assert
+        assert_eq!(wr.timeseries.len(), 100);
+    }
+
+    #[test]
+    fn summary_emits_quantile_timeseries() {
+        // Arrange
+        let text = "\
+# TYPE rpc_duration summary
+rpc_duration{quantile=\"0.5\"} 0.05
+rpc_duration{quantile=\"0.99\"} 0.5
+rpc_duration_sum 100
+rpc_duration_count 200
+";
+
+        // Act
+        let wr = parse_text_to_write_request(text).expect("parse failed");
+
+        // Assert — 2 quantiles + _sum + _count = 4
+        assert_eq!(wr.timeseries.len(), 4);
+        let quantiles: Vec<_> = wr.timeseries.iter()
+            .filter(|ts| ts.labels.iter().any(|l| l.name == "quantile"))
+            .collect();
+        assert_eq!(quantiles.len(), 2);
     }
 }
diff --git a/tests/remote_write/fault_injection.rs b/tests/remote_write/fault_injection.rs
new file mode 100644
index 0000000..e449089
--- /dev/null
+++ b/tests/remote_write/fault_injection.rs
@@ -0,0 +1,500 @@
+//! Fault injection tests for `RemoteWriteSender::push_once`.
+//!
+//! These tests do NOT require Docker — they use in-process TCP listeners
+//! to simulate various failure modes.
+
+use std::collections::HashMap;
+use std::time::Duration;
+
+use distributed_metrics::config::RemoteWriteDestination;
+use distributed_metrics::remote_write::{parse_text_to_write_request, RemoteWriteSender};
+use tokio::io::AsyncWriteExt;
+use tokio::net::TcpListener;
+
+fn make_dest(url: &str) -> RemoteWriteDestination {
+    RemoteWriteDestination {
+        name: "fault-test".to_string(),
+        url: url.to_string(),
+        username: None,
+        password: None,
+        headers: HashMap::new(),
+        interval: Duration::from_secs(15),
+        timeout: Duration::from_secs(5),
+    }
+}
+
+const VALID_PROM_TEXT: &str = "# TYPE test_gauge gauge\ntest_gauge 42\n";
+
+// ---------------------------------------------------------------------------
+// Connection failures
+// ---------------------------------------------------------------------------
+
+#[tokio::test]
+async fn push_to_refused_port_returns_error() {
+    // Arrange — bind and immediately drop to guarantee the port is refused
+    let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind failed");
+    let port = listener.local_addr().expect("local_addr failed").port();
+    drop(listener);
+
+    let dest = make_dest(&format!("http://127.0.0.1:{}/api/v1/write", port));
+    let client = reqwest::Client::new();
+
+    // Act
+    let result = RemoteWriteSender::push_once(&dest, &client, VALID_PROM_TEXT).await;
+
+    // Assert
+    assert!(result.is_err());
+    let err = result.expect_err("expected connection error");
+    let msg = err.to_string();
+    assert!(
+        msg.contains("error sending request") || msg.contains("connection refused") || msg.contains("Connection refused"),
+        "unexpected error: {}",
+        msg
+    );
+}
+
+#[tokio::test]
+async fn push_to_invalid_hostname_returns_error() {
+    // Arrange
+    let dest = make_dest("http://this-host-does-not-exist.invalid:9999/api/v1/write");
+    let client = reqwest::Client::builder()
+        .timeout(Duration::from_secs(3))
+        .build()
+        .expect("client build failed");
+
+    // Act
+    let result = RemoteWriteSender::push_once(&dest, &client, VALID_PROM_TEXT).await;
+
+    // Assert
+    assert!(result.is_err());
+}
+
+// ---------------------------------------------------------------------------
+// HTTP error responses
+// ---------------------------------------------------------------------------
+
+async fn start_mock_server(
+    status_code: u16,
+    body: &str,
+) -> (tokio::task::JoinHandle<()>, String) {
+    let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind failed");
+    let port = listener.local_addr().expect("local_addr failed").port();
+    let url = format!("http://127.0.0.1:{}/api/v1/write", port);
+
+    let response_body = body.to_string();
+    let handle = tokio::spawn(async move {
+        // Accept one connection, read the request, send a canned response
+        let (mut stream, _) = listener.accept().await.expect("accept failed");
+
+        // Read until we get the double CRLF ending the headers
+        let mut buf = vec![0u8; 8192];
+        let mut total = 0;
+        loop {
+            let n = tokio::io::AsyncReadExt::read(&mut stream, &mut buf[total..])
+                .await
+                .expect("read failed");
+            if n == 0 {
+                break;
+            }
+            total += n;
+            if buf[..total].windows(4).any(|w| w == b"\r\n\r\n") {
+                break;
+            }
+        }
+
+        let response = format!(
+            "HTTP/1.1 {} Error\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+            status_code,
+            response_body.len(),
+            response_body
+        );
+        stream
+            .write_all(response.as_bytes())
+            .await
+            .expect("write failed");
+        stream.shutdown().await.expect("shutdown failed");
+    });
+
+    (handle, url)
+}
+
+#[tokio::test]
+async fn push_to_400_returns_error_with_status() {
+    // Arrange
+    let (server, url) = start_mock_server(400, "bad request: invalid protobuf").await;
+    let dest = make_dest(&url);
+    let client = reqwest::Client::new();
+
+    // Act
+    let result = RemoteWriteSender::push_once(&dest, &client, VALID_PROM_TEXT).await;
+    server.await.expect("server task failed");
+
+    // Assert
+    let err = result.expect_err("expected 400 error");
+    let msg = err.to_string();
+    assert!(msg.contains("400"), "error should contain status code: {}", msg);
+    assert!(
+        msg.contains("bad request"),
+        "error should contain response body: {}",
+        msg
+    );
+}
+
+#[tokio::test]
+async fn push_to_500_returns_error() {
+    // Arrange
+    let (server, url) = start_mock_server(500, "internal server error").await;
+    let dest = make_dest(&url);
+    let client = reqwest::Client::new();
+
+    // Act
+    let result = RemoteWriteSender::push_once(&dest, &client, VALID_PROM_TEXT).await;
+    server.await.expect("server task failed");
+
+    // Assert
+    let err = result.expect_err("expected 500 error");
+    assert!(err.to_string().contains("500"));
+}
+
+#[tokio::test]
+async fn push_to_429_returns_error() {
+    // Arrange — rate limiting
+    let (server, url) = start_mock_server(429, "rate limited").await;
+    let dest = make_dest(&url);
+    let client = reqwest::Client::new();
+
+    // Act
+    let result = RemoteWriteSender::push_once(&dest, &client, VALID_PROM_TEXT).await;
+    server.await.expect("server task failed");
+
+    // Assert
+    let err = result.expect_err("expected 429 error");
+    assert!(err.to_string().contains("429"));
+}
+
+#[tokio::test]
+async fn error_body_truncated_to_1024_bytes() {
+    // Arrange — server returns a 5KB error body of repeated 'x'
+    let huge_body = "x".repeat(5000);
+    let (server, url) = start_mock_server(500, &huge_body).await;
+    let dest = make_dest(&url);
+    let client = reqwest::Client::new();
+
+    // Act
+    let result = RemoteWriteSender::push_once(&dest, &client, VALID_PROM_TEXT).await;
+    server.await.expect("server task failed");
+
+    // Assert
+    let err = result.expect_err("expected error");
+    let msg = err.to_string();
+    // The full message is "remote_write returned 500 Error: <body>"
+    // The body portion is truncated to 1024 chars, so the total message
+    // should be well under 5000 (the original body size).
+    assert!(
+        msg.len() < 1200,
+        "error message should be truncated, got {} bytes",
+        msg.len()
+    );
+    // Count the number of 'x' characters — should be exactly 1024 (truncated from 5000)
+    let x_count = msg.chars().filter(|c| *c == 'x').count();
+    assert_eq!(
+        x_count, 1024,
+        "body should be truncated to exactly 1024 chars of 'x', got {}",
+        x_count
+    );
+}
+
+#[tokio::test]
+async fn error_body_under_1024_not_truncated() {
+    // Arrange — server returns a small error body
+    let small_body = "short error message";
+    let (server, url) = start_mock_server(500, small_body).await;
+    let dest = make_dest(&url);
+    let client = reqwest::Client::new();
+
+    // Act
+    let result = RemoteWriteSender::push_once(&dest, &client, VALID_PROM_TEXT).await;
+    server.await.expect("server task failed");
+
+    // Assert — full body should be preserved
+    let err = result.expect_err("expected error");
+    let msg = err.to_string();
+    assert!(
+        msg.contains("short error message"),
+        "small error body should not be truncated: {}",
+        msg
+    );
+}
+
+// ---------------------------------------------------------------------------
+// Timeout
+// ---------------------------------------------------------------------------
+
+#[tokio::test]
+async fn push_times_out_on_slow_server() {
+    // Arrange — server that accepts connection but never responds
+    let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind failed");
+    let port = listener.local_addr().expect("local_addr failed").port();
+    let url = format!("http://127.0.0.1:{}/api/v1/write", port);
+
+    let server = tokio::spawn(async move {
+        let (mut stream, _) = listener.accept().await.expect("accept failed");
+        // Read the request but never respond
+        let mut buf = vec![0u8; 8192];
+        let _ = tokio::io::AsyncReadExt::read(&mut stream, &mut buf).await;
+        // Hold the connection open for longer than the client timeout
+        tokio::time::sleep(Duration::from_secs(30)).await;
+    });
+
+    let mut dest = make_dest(&url);
+    dest.timeout = Duration::from_secs(1); // Short timeout
+    let client = reqwest::Client::new();
+
+    // Act
+    let start = std::time::Instant::now();
+    let result = RemoteWriteSender::push_once(&dest, &client, VALID_PROM_TEXT).await;
+    let elapsed = start.elapsed();
+
+    // Assert
+    assert!(result.is_err(), "should have timed out");
+    assert!(
+        elapsed < Duration::from_secs(5),
+        "should have timed out in ~1s, took {:?}",
+        elapsed
+    );
+
+    server.abort();
+}
+
+// ---------------------------------------------------------------------------
+// Invalid input
+// ---------------------------------------------------------------------------
+
+#[tokio::test]
+async fn push_empty_text_is_noop() {
+    // Arrange — parse_text_to_write_request("") returns empty WriteRequest
+    // which still encodes fine — it's a valid (empty) protobuf
+    let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind failed");
+    let port = listener.local_addr().expect("local_addr failed").port();
+
+    // Server that accepts and returns 204
+    let server = tokio::spawn(async move {
+        let (mut stream, _) = listener.accept().await.expect("accept failed");
+        let mut buf = vec![0u8; 8192];
+        let mut total = 0;
+        loop {
+            let n = tokio::io::AsyncReadExt::read(&mut stream, &mut buf[total..])
+                .await
+                .expect("read failed");
+            if n == 0 { break; }
+            total += n;
+            if buf[..total].windows(4).any(|w| w == b"\r\n\r\n") { break; }
+        }
+        let response = "HTTP/1.1 204 No Content\r\nConnection: close\r\n\r\n";
+        stream.write_all(response.as_bytes()).await.expect("write failed");
+        stream.shutdown().await.expect("shutdown failed");
+    });
+
+    let dest = make_dest(&format!("http://127.0.0.1:{}/api/v1/write", port));
+    let client = reqwest::Client::new();
+
+    // Act
+    let result = RemoteWriteSender::push_once(&dest, &client, "").await;
+    server.await.expect("server task failed");
+
+    // Assert — empty text produces empty WriteRequest, server returns 204 = success
+    assert!(result.is_ok());
+}
+
+#[tokio::test]
+async fn parse_garbage_input_returns_empty() {
+    // Arrange — completely invalid prometheus text
+    let text = "this is not prometheus format at all!!!";
+
+    // Act
+    let result = parse_text_to_write_request(text);
+
+    // Assert — prometheus-parse doesn't error on unrecognized lines, just ignores them
+    assert!(result.is_ok());
+    assert!(result.expect("parse failed").timeseries.is_empty());
+}
+
+#[tokio::test]
+async fn parse_partial_line_does_not_panic() {
+    // Arrange — truncated metric line
+    let text = "# TYPE g gauge\ng{foo=";
+
+    // Act
+    let result = parse_text_to_write_request(text);
+
+    // Assert — should either parse successfully (skipping bad line) or return error, not panic
+    // We don't care which — just that it doesn't crash
+    let _ = result;
+}
+
+#[tokio::test]
+async fn parse_binary_garbage_does_not_panic() {
+    // Arrange — random bytes
+    let text = std::str::from_utf8(&[0x00, 0x01, 0x02, 0x7f, 0x20, 0x0a]).unwrap_or("");
+
+    // Act
+    let result = parse_text_to_write_request(text);
+
+    // Assert — should not panic
+    let _ = result;
+}
+
+// ---------------------------------------------------------------------------
+// Authentication
+// ---------------------------------------------------------------------------
+
+#[tokio::test]
+async fn push_with_basic_auth_sends_authorization_header() {
+    // Arrange — mock server that checks for Authorization header
+    let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind failed");
+    let port = listener.local_addr().expect("local_addr failed").port();
+    let url = format!("http://127.0.0.1:{}/api/v1/write", port);
+
+    let server = tokio::spawn(async move {
+        let (mut stream, _) = listener.accept().await.expect("accept failed");
+        let mut buf = vec![0u8; 8192];
+        let mut total = 0;
+        loop {
+            let n = tokio::io::AsyncReadExt::read(&mut stream, &mut buf[total..])
+                .await
+                .expect("read failed");
+            if n == 0 { break; }
+            total += n;
+            if buf[..total].windows(4).any(|w| w == b"\r\n\r\n") { break; }
+        }
+
+        let request = String::from_utf8_lossy(&buf[..total]).to_lowercase();
+        let has_auth = request.contains("authorization: basic");
+
+        let (status, body) = if has_auth {
+            ("204 No Content", "")
+        } else {
+            ("401 Unauthorized", "missing auth")
+        };
+
+        let response = format!(
+            "HTTP/1.1 {}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+            status,
+            body.len(),
+            body
+        );
+        stream.write_all(response.as_bytes()).await.expect("write failed");
+        stream.shutdown().await.expect("shutdown failed");
+    });
+
+    let mut dest = make_dest(&url);
+    dest.username = Some("testuser".to_string());
+    dest.password = Some("testpass".to_string());
+    let client = reqwest::Client::new();
+
+    // Act
+    let result = RemoteWriteSender::push_once(&dest, &client, VALID_PROM_TEXT).await;
+    server.await.expect("server task failed");
+
+    // Assert
+    assert!(result.is_ok(), "push with valid auth should succeed");
+}
+
+#[tokio::test]
+async fn push_without_auth_to_auth_required_server_returns_401() {
+    // Arrange
+    let (server, url) = start_mock_server(401, "unauthorized").await;
+    let dest = make_dest(&url); // no username/password
+    let client = reqwest::Client::new();
+
+    // Act
+    let result = RemoteWriteSender::push_once(&dest, &client, VALID_PROM_TEXT).await;
+    server.await.expect("server task failed");
+
+    // Assert
+    let err = result.expect_err("expected 401 error");
+    assert!(err.to_string().contains("401"));
+}
+
+// ---------------------------------------------------------------------------
+// Custom headers
+// ---------------------------------------------------------------------------
+
+#[tokio::test]
+async fn push_sends_custom_headers() {
+    // Arrange — mock server that checks for custom header
+    let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind failed");
+    let port = listener.local_addr().expect("local_addr failed").port();
+    let url = format!("http://127.0.0.1:{}/api/v1/write", port);
+
+    let server = tokio::spawn(async move {
+        let (mut stream, _) = listener.accept().await.expect("accept failed");
+        let mut buf = vec![0u8; 8192];
+        let mut total = 0;
+        loop {
+            let n = tokio::io::AsyncReadExt::read(&mut stream, &mut buf[total..])
+                .await
+                .expect("read failed");
+            if n == 0 { break; }
+            total += n;
+            if buf[..total].windows(4).any(|w| w == b"\r\n\r\n") { break; }
+        }
+
+        let request = String::from_utf8_lossy(&buf[..total]).to_lowercase();
+        let has_custom = request.contains("x-custom-token: secret123");
+
+        let (status, body) = if has_custom {
+            ("204 No Content", "")
+        } else {
+            ("403 Forbidden", "missing custom header")
+        };
+
+        let response = format!(
+            "HTTP/1.1 {}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+            status,
+            body.len(),
+            body
+        );
+        stream.write_all(response.as_bytes()).await.expect("write failed");
+        stream.shutdown().await.expect("shutdown failed");
+    });
+
+    let mut dest = make_dest(&url);
+    dest.headers
+        .insert("x-custom-token".to_string(), "secret123".to_string());
+    let client = reqwest::Client::new();
+
+    // Act
+    let result = RemoteWriteSender::push_once(&dest, &client, VALID_PROM_TEXT).await;
+    server.await.expect("server task failed");
+
+    // Assert
+    assert!(result.is_ok(), "push with custom header should succeed");
+}
+
+// ---------------------------------------------------------------------------
+// Server drops connection
+// ---------------------------------------------------------------------------
+
+#[tokio::test]
+async fn push_to_server_that_closes_immediately_returns_error() {
+    // Arrange — server accepts then immediately closes
+    let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind failed");
+    let port = listener.local_addr().expect("local_addr failed").port();
+    let url = format!("http://127.0.0.1:{}/api/v1/write", port);
+
+    let server = tokio::spawn(async move {
+        let (stream, _) = listener.accept().await.expect("accept failed");
+        drop(stream); // close immediately
+    });
+
+    let dest = make_dest(&url);
+    let client = reqwest::Client::new();
+
+    // Act
+    let result = RemoteWriteSender::push_once(&dest, &client, VALID_PROM_TEXT).await;
+    server.await.expect("server task failed");
+
+    // Assert
+    assert!(result.is_err(), "should error when server drops connection");
+}
diff --git a/tests/remote_write/main.rs b/tests/remote_write/main.rs
index f10ae70..0fa4a9a 100644
--- a/tests/remote_write/main.rs
+++ b/tests/remote_write/main.rs
@@ -6,6 +6,7 @@
 //! Requires Docker/Podman. Run with:
 //!   cargo test --test remote_write -- --ignored
 
+mod fault_injection;
 mod prometheus;
 mod victoriametrics;
 
@@ -41,6 +42,7 @@ impl RemoteWriteBackend {
             password: None,
             headers: HashMap::new(),
             interval: std::time::Duration::from_secs(15),
+            timeout: std::time::Duration::from_secs(30),
         }
     }