refactor!: remove iroh-test crate (#3162)

## Description

These testutils we are using, actually can be replaced through either
simpler code or other crates. See the individual commits for the
alternatives

## Breaking Changes

- `iroh-test` crate is gone

## Notes & open questions

<!-- Any notes, remarks or open questions you have to make about the PR.
-->

## Change checklist

- [ ] Self-review.
- [ ] Documentation updates following the [style
guide](https://rust-lang.github.io/rfcs/1574-more-api-documentation-conventions.html#appendix-a-full-conventions-text),
if relevant.
- [ ] Tests if relevant.
- [ ] All breaking changes documented.

Author: dignifiedquire

.github/workflows/tests.yaml

@@ -23,7 +23,7 @@ env:
   RUSTFLAGS: -Dwarnings
   RUSTDOCFLAGS: -Dwarnings
   SCCACHE_CACHE_SIZE: "10G"
-  CRATES_LIST: "iroh,iroh-bench,iroh-test,iroh-dns-server,iroh-relay,iroh-net-report"
+  CRATES_LIST: "iroh,iroh-bench,iroh-dns-server,iroh-relay,iroh-net-report"
   IROH_FORCE_STAGING_RELAYS: "1"
 
 jobs:

Cargo.lock

@@ -3,7 +3,6 @@ members = [
   "iroh-base",
   "iroh-dns-server",
   "iroh",
-  "iroh-test",
   "iroh/bench",
   "iroh-relay",
   "iroh-net-report",

Cargo.toml

@@ -132,7 +132,6 @@ This repository contains a workspace of crates:
 - `iroh`: The core library for hole-punching & communicating with relays.
 - `iroh-relay`: The relay server implementation. This is the code we run in production (and you can, too!).
 - `iroh-base`: Common types like `Hash`, key types or `RelayUrl`.
-- `iroh-test`: Test utilities.
 - `iroh-dns-server`: DNS server implementation powering the `n0_discovery` for NodeIds, running at dns.iroh.link.
 - `iroh-net-report`: Analyzes your host's networking ability & NAT.
 

README.md

@@ -29,7 +29,6 @@ thiserror = { version = "2", optional = true }
 getrandom = { version = "0.2", default-features = false, optional = true }
 
 [dev-dependencies]
-iroh-test = "0.28.0"
 postcard = { version = "1", features = ["use-std"] }
 proptest = "1.0.0"
 rand = "0.8"

iroh-base/Cargo.toml

@@ -350,7 +350,7 @@ fn decode_base32_hex(s: &str) -> Result<[u8; 32], KeyParsingError> {
 
 #[cfg(test)]
 mod tests {
-    use iroh_test::{assert_eq_hex, hexdump::parse_hexdump};
+    use data_encoding::HEXLOWER;
 
     use super::*;
 
@@ -360,10 +360,10 @@ mod tests {
             PublicKey::from_str("ae58ff8833241ac82d6ff7611046ed67b5072d142c588d0063e942d9a75502b6")
                 .unwrap();
         let bytes = postcard::to_stdvec(&public_key).unwrap();
-        let expected =
-            parse_hexdump("ae58ff8833241ac82d6ff7611046ed67b5072d142c588d0063e942d9a75502b6")
-                .unwrap();
-        assert_eq_hex!(bytes, expected);
+        let expected = HEXLOWER
+            .decode(b"ae58ff8833241ac82d6ff7611046ed67b5072d142c588d0063e942d9a75502b6")
+            .unwrap();
+        assert_eq!(bytes, expected);
     }
 
     #[test]

iroh-base/src/key.rs

@@ -135,7 +135,7 @@ impl<'de> Deserialize<'de> for NodeTicket {
 mod tests {
     use std::net::{Ipv4Addr, SocketAddr};
 
-    use iroh_test::{assert_eq_hex, hexdump::parse_hexdump};
+    use data_encoding::HEXLOWER;
 
     use super::*;
     use crate::key::{PublicKey, SecretKey};
@@ -188,15 +188,24 @@ mod tests {
                     .as_bytes(),
             )
             .unwrap();
-        let expected = parse_hexdump("
-            00 # variant
-            ae58ff8833241ac82d6ff7611046ed67b5072d142c588d0063e942d9a75502b6 # node id, 32 bytes, see above
-            01 # relay url present
-            10 687474703a2f2f646572702e6d652e2f # relay url, 16 bytes, see above
-            01 # one direct address
-            00 # ipv4
-            7f000001 8008 # address, see above
-        ").unwrap();
-        assert_eq_hex!(base32, expected);
+        let expected = [
+            // variant
+            "00",
+            // node id, 32 bytes, see above
+            "ae58ff8833241ac82d6ff7611046ed67b5072d142c588d0063e942d9a75502b6",
+            // relay url present
+            "01",
+            // relay url, 16 bytes, see above
+            "10",
+            "687474703a2f2f646572702e6d652e2f",
+            // one direct address
+            "01",
+            // ipv4
+            "00",
+            // address, see above
+            "7f0000018008",
+        ];
+        let expected = HEXLOWER.decode(expected.concat().as_bytes()).unwrap();
+        assert_eq!(base32, expected);
     }
 }

iroh-base/src/ticket/node.rs

@@ -61,11 +61,11 @@ z32 = "1.1.1"
 criterion = "0.5.1"
 hickory-resolver = "=0.25.0-alpha.4"
 iroh = { path = "../iroh" }
-iroh-test = { path = "../iroh-test" }
 pkarr = { version = "2.3.1", features = ["rand"] }
 rand = "0.8"
 rand_chacha = "0.3.1"
 testresult = "0.4.1"
+tracing-test = "0.2.5"
 
 [[bench]]
 name = "write"

iroh-dns-server/Cargo.toml

@@ -34,6 +34,7 @@ mod tests {
     };
     use pkarr::{PkarrClient, SignedPacket};
     use testresult::TestResult;
+    use tracing_test::traced_test;
     use url::Url;
 
     use crate::{
@@ -45,8 +46,8 @@ mod tests {
     };
 
     #[tokio::test]
+    #[traced_test]
     async fn pkarr_publish_dns_resolve() -> Result<()> {
-        iroh_test::logging::setup_multithreaded();
         let (server, nameserver, http_url) = Server::spawn_for_tests().await?;
         let pkarr_relay_url = {
             let mut url = http_url.clone();
@@ -158,8 +159,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn integration_smoke() -> Result<()> {
-        iroh_test::logging::setup_multithreaded();
         let (server, nameserver, http_url) = Server::spawn_for_tests().await?;
 
         let pkarr_relay = {
@@ -190,8 +191,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn store_eviction() -> TestResult<()> {
-        iroh_test::logging::setup_multithreaded();
         let options = ZoneStoreOptions {
             eviction: Duration::from_millis(100),
             eviction_interval: Duration::from_millis(100),
@@ -220,9 +221,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn integration_mainline() -> Result<()> {
-        iroh_test::logging::setup_multithreaded();
-
         // run a mainline testnet
         let testnet = pkarr::mainline::dht::Testnet::new(5);
         let bootstrap = testnet.bootstrap.clone();

iroh-dns-server/src/lib.rs

@@ -39,10 +39,10 @@ url = { version = "2.4" }
 
 [dev-dependencies]
 iroh-relay = { path = "../iroh-relay", features = ["test-utils", "server"] }
-iroh-test = { path = "../iroh-test" }
 pretty_assertions = "1.4"
 testresult = "0.4.0"
 tokio = { version = "1", default-features = false, features = ["test-util"] }
+tracing-test = "0.2.5"
 
 [features]
 default = ["metrics"]

iroh-net-report/Cargo.toml

@@ -187,6 +187,8 @@ pub(crate) mod tests {
         sync::{atomic::AtomicUsize, OnceLock},
     };
 
+    use tracing_test::traced_test;
+
     use super::*;
 
     static DNS_RESOLVER: OnceLock<TokioResolver> = OnceLock::new();
@@ -243,8 +245,8 @@ pub(crate) mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn stagger_basic() {
-        let _logging = iroh_test::logging::setup();
         const CALL_RESULTS: &[Result<u8, u8>] = &[Err(2), Ok(3), Ok(5), Ok(7)];
         static DONE_CALL: AtomicUsize = AtomicUsize::new(0);
         let f = || {

iroh-net-report/src/dns.rs

@@ -1006,6 +1006,7 @@ mod tests {
     use netwatch::IpFamily;
     use tokio_util::sync::CancellationToken;
     use tracing::info;
+    use tracing_test::traced_test;
 
     use super::*;
     use crate::{ping::Pinger, stun_utils::bind_local_stun_socket};
@@ -1143,8 +1144,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_basic() -> Result<()> {
-        let _guard = iroh_test::logging::setup();
         let (stun_addr, stun_stats, _cleanup_guard) =
             stun_utils::serve("127.0.0.1".parse().unwrap()).await?;
 
@@ -1186,9 +1187,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_udp_blocked() -> Result<()> {
-        let _guard = iroh_test::logging::setup();
-
         // Create a "STUN server", which will never respond to anything.  This is how UDP to
         // the STUN server being blocked will look like from the client's perspective.
         let blackhole = tokio::net::UdpSocket::bind("127.0.0.1:0").await?;

iroh-net-report/src/lib.rs

@@ -124,14 +124,14 @@ mod tests {
     use std::net::{Ipv4Addr, Ipv6Addr};
 
     use tracing::error;
+    use tracing_test::traced_test;
 
     use super::*;
 
     #[tokio::test]
     #[ignore] // Doesn't work in CI
+    #[traced_test]
     async fn test_ping_google() -> Result<()> {
-        let _guard = iroh_test::logging::setup();
-
         // Public DNS addrs from google based on
         // https://developers.google.com/speed/public-dns/docs/using
 
@@ -159,9 +159,8 @@ mod tests {
 
     // See net_report::reportgen::tests::test_icmp_probe_eu_relay for permissions to ping.
     #[tokio::test]
+    #[traced_test]
     async fn test_ping_localhost() {
-        let _guard = iroh_test::logging::setup();
-
         let pinger = Pinger::new();
 
         match pinger.send(Ipv4Addr::LOCALHOST.into(), b"data").await {

iroh-net-report/src/ping.rs

@@ -1356,12 +1356,13 @@ mod tests {
     use std::net::{Ipv4Addr, Ipv6Addr};
 
     use testresult::TestResult;
+    use tracing_test::traced_test;
 
     use super::{super::test_utils, *};
 
     #[tokio::test]
+    #[traced_test]
     async fn test_update_report_stun_working() {
-        let _logging = iroh_test::logging::setup();
         let (_server_a, relay_a) = test_utils::relay().await;
         let (_server_b, relay_b) = test_utils::relay().await;
 
@@ -1446,8 +1447,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_update_report_icmp() {
-        let _logging = iroh_test::logging::setup();
         let (_server_a, relay_a) = test_utils::relay().await;
         let (_server_b, relay_b) = test_utils::relay().await;
 
@@ -1556,8 +1557,8 @@ mod tests {
     //
     // TODO: Not sure what about IPv6 pings using sysctl.
     #[tokio::test]
+    #[traced_test]
     async fn test_icmpk_probe() {
-        let _logging_guard = iroh_test::logging::setup();
         let pinger = Pinger::new();
         let (server, node) = test_utils::relay().await;
         let addr = server.stun_addr().expect("test relay serves stun");
@@ -1607,7 +1608,6 @@ mod tests {
 
     #[tokio::test]
     async fn test_measure_https_latency() -> TestResult {
-        let _logging_guard = iroh_test::logging::setup();
         let (server, relay) = test_utils::relay().await;
         let dns_resolver = crate::dns::tests::resolver();
         tracing::info!(relay_url = ?relay.url , "RELAY_URL");
@@ -1626,8 +1626,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_quic_probe() -> TestResult {
-        let _logging_guard = iroh_test::logging::setup();
         let (server, relay) = test_utils::relay().await;
         let client_config = iroh_relay::client::make_dangerous_client_config();
         let ep = quinn::Endpoint::client(SocketAddr::new(Ipv4Addr::LOCALHOST.into(), 0))?;

iroh-net-report/src/reportgen.rs

@@ -181,10 +181,12 @@ mod tests {
     use bytes::BytesMut;
     use tokio::sync::mpsc;
     use tracing::info;
+    use tracing_test::traced_test;
 
     use super::*;
 
     #[tokio::test]
+    #[traced_test]
     async fn test_hairpin_success() {
         for i in 0..100 {
             let now = Instant::now();
@@ -194,13 +196,12 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_hairpin_failure() {
         test_hairpin(false).await;
     }
 
     async fn test_hairpin(hairpinning_works: bool) {
-        let _guard = iroh_test::logging::setup();
-
         // Setup fake net_report and reportstate actors, hairpinning interacts with them.
         let (net_report_tx, mut net_report_rx) = mpsc::channel(32);
         let net_report_addr = net_report::Addr {
@@ -275,9 +276,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_client_drop() {
-        let _guard = iroh_test::logging::setup();
-
         // Setup fake net_report and reportstate actors, hairpinning interacts with them.
         let (net_report_tx, _net_report_rx) = mpsc::channel(32);
         let net_report_addr = net_report::Addr {

iroh-net-report/src/reportgen/hairpin.rs

@@ -566,6 +566,7 @@ fn sort_relays<'a>(
 #[cfg(test)]
 mod tests {
     use pretty_assertions::assert_eq;
+    use tracing_test::traced_test;
 
     use super::*;
     use crate::{test_utils, RelayLatencies};
@@ -796,8 +797,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_plan_with_report() {
-        let _logging = iroh_test::logging::setup();
         let (_servers, relay_map) = test_utils::relay_map(2).await;
         let relay_node_1 = relay_map.nodes().next().unwrap().clone();
         let relay_node_2 = relay_map.nodes().nth(1).unwrap().clone();
@@ -988,8 +989,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_relay_sort_two_latencies() {
-        let _logging = iroh_test::logging::setup();
         let (_servers, relay_map) = test_utils::relay_map(2).await;
         let r1 = relay_map.nodes().next().unwrap();
         let r2 = relay_map.nodes().nth(1).unwrap();
@@ -1007,8 +1008,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_relay_sort_equal_latencies() {
-        let _logging = iroh_test::logging::setup();
         let (_servers, relay_map) = test_utils::relay_map(2).await;
         let r1 = relay_map.nodes().next().unwrap();
         let r2 = relay_map.nodes().nth(1).unwrap();
@@ -1049,8 +1050,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_relay_sort_no_latency() {
-        let _logging = iroh_test::logging::setup();
         let (_servers, relay_map) = test_utils::relay_map(2).await;
         let r1 = relay_map.nodes().next().unwrap();
         let r2 = relay_map.nodes().nth(1).unwrap();

iroh-net-report/src/reportgen/probes.rs

@@ -116,8 +116,8 @@ tokio = { version = "1", features = [
     "test-util",
 ] }
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
-iroh-test = { path = "../iroh-test" }
 serde_json = "1"
+tracing-test = "0.2.5"
 
 [build-dependencies]
 cfg_aliases = { version = "0.2" }

iroh-relay/Cargo.toml

@@ -369,13 +369,13 @@ mod tests {
     use std::str::FromStr;
 
     use anyhow::Result;
+    use tracing_test::traced_test;
 
     use super::*;
 
     #[test]
+    #[traced_test]
     fn test_host_header_value() -> Result<()> {
-        let _guard = iroh_test::logging::setup();
-
         let cases = [
             (
                 "https://euw1-1.relay.iroh.network.",

iroh-relay/src/client/connect_relay.rs

@@ -604,6 +604,7 @@ pub(crate) async fn recv_frame<S: Stream<Item = anyhow::Result<Frame>> + Unpin>(
 
 #[cfg(test)]
 mod tests {
+    use data_encoding::HEXLOWER;
     use tokio_util::codec::{FramedRead, FramedWrite};
 
     use super::*;
@@ -726,10 +727,17 @@ mod tests {
 
         for (frame, expected_hex) in frames {
             let bytes = frame.encode_for_ws_msg();
-            // To regenerate the hexdumps:
-            // let hexdump = iroh_test::hexdump::print_hexdump(bytes, []);
-            // println!("{hexdump}");
-            let expected_bytes = iroh_test::hexdump::parse_hexdump(expected_hex)?;
+            let stripped: Vec<u8> = expected_hex
+                .chars()
+                .filter_map(|s| {
+                    if s.is_ascii_whitespace() {
+                        None
+                    } else {
+                        Some(s as u8)
+                    }
+                })
+                .collect();
+            let expected_bytes = HEXLOWER.decode(&stripped).unwrap();
             assert_eq!(bytes, expected_bytes);
         }
 

iroh-relay/src/protos/relay.rs

@@ -272,16 +272,17 @@ impl QuicClient {
 mod tests {
     use std::net::Ipv4Addr;
 
+    use tracing_test::traced_test;
+
     use super::{
         server::{QuicConfig, QuicServer},
         *,
     };
 
     #[tokio::test]
+    #[traced_test]
     async fn quic_endpoint_basic() -> anyhow::Result<()> {
         let host: Ipv4Addr = "127.0.0.1".parse()?;
-        let _guard = iroh_test::logging::setup();
-
         // create a server config with self signed certificates
         let (_, server_config) = super::super::server::testing::self_signed_tls_certs_and_config();
         let bind_addr = SocketAddr::new(host.into(), 0);

iroh-relay/src/quic.rs

@@ -812,6 +812,7 @@ mod tests {
     use iroh_base::{NodeId, SecretKey};
     use n0_future::{FutureExt, SinkExt};
     use testresult::TestResult;
+    use tracing_test::traced_test;
 
     use super::*;
     use crate::{
@@ -856,8 +857,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_no_services() {
-        let _guard = iroh_test::logging::setup();
         let mut server = Server::spawn(ServerConfig::<(), ()>::default())
             .await
             .unwrap();
@@ -869,8 +870,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_conflicting_bind() {
-        let _guard = iroh_test::logging::setup();
         let mut server = Server::spawn(ServerConfig::<(), ()> {
             relay: Some(RelayConfig {
                 http_bind_addr: (Ipv4Addr::LOCALHOST, 1234).into(),
@@ -893,8 +894,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_root_handler() {
-        let _guard = iroh_test::logging::setup();
         let server = spawn_local_relay().await.unwrap();
         let url = format!("http://{}", server.http_addr().unwrap());
 
@@ -905,8 +906,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_captive_portal_service() {
-        let _guard = iroh_test::logging::setup();
         let server = spawn_local_relay().await.unwrap();
         let url = format!("http://{}/generate_204", server.http_addr().unwrap());
         let challenge = "123az__.";
@@ -926,8 +927,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_relay_client_legacy_route() {
-        let _guard = iroh_test::logging::setup();
         let server = spawn_local_relay().await.unwrap();
         // We're testing the legacy endpoint at `/derp`
         let endpoint_url = format!("http://{}/derp", server.http_addr().unwrap());
@@ -944,8 +945,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_relay_clients_both_relay() -> TestResult<()> {
-        let _guard = iroh_test::logging::setup();
         let server = spawn_local_relay().await.unwrap();
         let relay_url = format!("http://{}", server.http_addr().unwrap());
         let relay_url: RelayUrl = relay_url.parse().unwrap();
@@ -996,8 +997,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_relay_clients_both_websockets() -> TestResult<()> {
-        let _guard = iroh_test::logging::setup();
         let server = spawn_local_relay().await?;
 
         let relay_url = format!("http://{}", server.http_addr().unwrap());
@@ -1058,8 +1059,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_relay_clients_websocket_and_relay() -> TestResult<()> {
-        let _guard = iroh_test::logging::setup();
         let server = spawn_local_relay().await.unwrap();
 
         let relay_url = format!("http://{}", server.http_addr().unwrap());
@@ -1114,8 +1115,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_stun() {
-        let _guard = iroh_test::logging::setup();
         let server = Server::spawn(ServerConfig::<(), ()> {
             relay: None,
             stun: Some(StunConfig {
@@ -1146,9 +1147,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_relay_access_control() -> Result<()> {
-        let _guard = iroh_test::logging::setup();
-
         let a_secret_key = SecretKey::generate(rand::thread_rng());
         let a_key = a_secret_key.public();
 

iroh-relay/src/server.rs

@@ -559,6 +559,7 @@ mod tests {
     use testresult::TestResult;
     use tokio_util::codec::Framed;
     use tracing::info;
+    use tracing_test::traced_test;
 
     use super::*;
     use crate::{
@@ -567,9 +568,8 @@ mod tests {
     };
 
     #[tokio::test]
+    #[traced_test]
     async fn test_client_actor_basic() -> Result<()> {
-        let _logging = iroh_test::logging::setup();
-
         let (send_queue_s, send_queue_r) = mpsc::channel(10);
         let (disco_send_queue_s, disco_send_queue_r) = mpsc::channel(10);
         let (peer_gone_s, peer_gone_r) = mpsc::channel(10);
@@ -678,9 +678,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_rate_limit() -> TestResult {
-        let _logging = iroh_test::logging::setup();
-
         const LIMIT: u32 = 50;
         const MAX_FRAMES: u32 = 100;
 

iroh-relay/src/server/client.rs

@@ -706,7 +706,7 @@ mod tests {
     use n0_future::{SinkExt, StreamExt};
     use reqwest::Url;
     use tracing::info;
-    use tracing_subscriber::{prelude::*, EnvFilter};
+    use tracing_test::traced_test;
 
     use super::*;
     use crate::client::{
@@ -740,9 +740,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_http_clients_and_server() -> Result<()> {
-        let _guard = iroh_test::logging::setup();
-
         let a_key = SecretKey::generate(rand::thread_rng());
         let b_key = SecretKey::generate(rand::thread_rng());
 
@@ -846,9 +845,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_https_clients_and_server() -> Result<()> {
-        let _logging = iroh_test::logging::setup();
-
         let a_key = SecretKey::generate(rand::thread_rng());
         let b_key = SecretKey::generate(rand::thread_rng());
 
@@ -929,9 +927,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_server_basic() -> Result<()> {
-        let _guard = iroh_test::logging::setup();
-
         info!("Create the server.");
         let service = RelayService::new(
             Default::default(),
@@ -1019,12 +1016,6 @@ mod tests {
 
     #[tokio::test]
     async fn test_server_replace_client() -> Result<()> {
-        tracing_subscriber::registry()
-            .with(tracing_subscriber::fmt::layer().with_writer(std::io::stderr))
-            .with(EnvFilter::from_default_env())
-            .try_init()
-            .ok();
-
         info!("Create the server.");
         let service = RelayService::new(
             Default::default(),

iroh-relay/src/server/http_server.rs

@@ -125,10 +125,10 @@ tokio = { version = "1", features = [
     "test-util",
 ] }
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
-iroh-test = { path = "../iroh-test" }
 serde_json = "1"
 testresult = "0.4.0"
 iroh-relay = { path = "../iroh-relay", default-features = false, features = ["test-utils", "server"] }
+tracing-test = "0.2.5"
 
 [features]
 default = ["metrics"]

iroh-test/Cargo.toml

@@ -446,6 +446,7 @@ mod tests {
     use rand::Rng;
     use testresult::TestResult;
     use tokio_util::task::AbortOnDropHandle;
+    use tracing_test::traced_test;
 
     use super::*;
     use crate::RelayMode;
@@ -563,8 +564,8 @@ mod tests {
 
     /// This is a smoke test for our discovery mechanism.
     #[tokio::test]
+    #[traced_test]
     async fn endpoint_discovery_simple_shared() -> anyhow::Result<()> {
-        let _guard = iroh_test::logging::setup();
         let disco_shared = TestDiscoveryShared::default();
         let (ep1, _guard1) = {
             let secret = SecretKey::generate(rand::thread_rng());
@@ -585,8 +586,8 @@ mod tests {
 
     /// This test adds an empty discovery which provides no addresses.
     #[tokio::test]
+    #[traced_test]
     async fn endpoint_discovery_combined_with_empty() -> anyhow::Result<()> {
-        let _guard = iroh_test::logging::setup();
         let disco_shared = TestDiscoveryShared::default();
         let (ep1, _guard1) = {
             let secret = SecretKey::generate(rand::thread_rng());
@@ -616,8 +617,8 @@ mod tests {
     /// This is to make sure that as long as one of the discoveries returns a working address, we
     /// will connect successfully.
     #[tokio::test]
+    #[traced_test]
     async fn endpoint_discovery_combined_with_empty_and_wrong() -> anyhow::Result<()> {
-        let _guard = iroh_test::logging::setup();
         let disco_shared = TestDiscoveryShared::default();
         let (ep1, _guard1) = {
             let secret = SecretKey::generate(rand::thread_rng());
@@ -644,8 +645,8 @@ mod tests {
 
     /// This test only has the "lying" discovery. It is here to make sure that this actually fails.
     #[tokio::test]
+    #[traced_test]
     async fn endpoint_discovery_combined_wrong_only() -> anyhow::Result<()> {
-        let _guard = iroh_test::logging::setup();
         let disco_shared = TestDiscoveryShared::default();
         let (ep1, _guard1) = {
             let secret = SecretKey::generate(rand::thread_rng());
@@ -669,8 +670,8 @@ mod tests {
     /// This test first adds a wrong address manually (e.g. from an outdated&node_id ticket).
     /// Connect should still succeed because the discovery service will be invoked (after a delay).
     #[tokio::test]
+    #[traced_test]
     async fn endpoint_discovery_with_wrong_existing_addr() -> anyhow::Result<()> {
-        let _guard = iroh_test::logging::setup();
         let disco_shared = TestDiscoveryShared::default();
         let (ep1, _guard1) = {
             let secret = SecretKey::generate(rand::thread_rng());
@@ -759,6 +760,7 @@ mod test_dns_pkarr {
     use iroh_relay::RelayMap;
     use n0_future::time::Duration;
     use tokio_util::task::AbortOnDropHandle;
+    use tracing_test::traced_test;
 
     use crate::{
         discovery::pkarr::PkarrPublisher,
@@ -774,9 +776,8 @@ mod test_dns_pkarr {
     const PUBLISH_TIMEOUT: Duration = Duration::from_secs(10);
 
     #[tokio::test]
+    #[traced_test]
     async fn dns_resolve() -> Result<()> {
-        let _logging_guard = iroh_test::logging::setup();
-
         let origin = "testdns.example".to_string();
         let state = State::new(origin.clone());
         let (nameserver, _dns_drop_guard) = run_dns_server(state.clone()).await?;
@@ -799,9 +800,8 @@ mod test_dns_pkarr {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn pkarr_publish_dns_resolve() -> Result<()> {
-        let _logging_guard = iroh_test::logging::setup();
-
         let origin = "testdns.example".to_string();
 
         let dns_pkarr_server = DnsPkarrServer::run_with_origin(origin.clone()).await?;
@@ -832,9 +832,8 @@ mod test_dns_pkarr {
     const TEST_ALPN: &[u8] = b"TEST";
 
     #[tokio::test]
+    #[traced_test]
     async fn pkarr_publish_dns_discover() -> Result<()> {
-        let _logging_guard = iroh_test::logging::setup();
-
         let dns_pkarr_server = DnsPkarrServer::run().await?;
         let (relay_map, _relay_url, _relay_guard) = run_relay_server().await?;
 

iroh-test/README.md

@@ -404,12 +404,13 @@ mod tests {
         use iroh_base::SecretKey;
         use n0_future::StreamExt;
         use testresult::TestResult;
+        use tracing_test::traced_test;
 
         use super::super::*;
 
         #[tokio::test]
+        #[traced_test]
         async fn local_swarm_discovery_publish_resolve() -> TestResult {
-            let _guard = iroh_test::logging::setup();
             let (_, discovery_a) = make_discoverer()?;
             let (node_id_b, discovery_b) = make_discoverer()?;
 
@@ -441,9 +442,8 @@ mod tests {
         }
 
         #[tokio::test]
+        #[traced_test]
         async fn local_swarm_discovery_subscribe() -> TestResult {
-            let _guard = iroh_test::logging::setup();
-
             let num_nodes = 5;
             let mut node_ids = BTreeSet::new();
             let mut discoverers = vec![];

iroh-test/src/hexdump.rs

@@ -410,13 +410,14 @@ mod tests {
     use iroh_base::RelayUrl;
     use pkarr::mainline::dht::DhtSettings;
     use testresult::TestResult;
+    use tracing_test::traced_test;
 
     use super::*;
 
     #[tokio::test]
     #[ignore = "flaky"]
+    #[traced_test]
     async fn dht_discovery_smoke() -> TestResult {
-        let _logging_guard = iroh_test::logging::setup();
         let ep = crate::Endpoint::builder().bind().await?;
         let secret = ep.secret_key().clone();
         let testnet = pkarr::mainline::dht::Testnet::new(2);

iroh-test/src/lib.rs

@@ -383,14 +383,16 @@ async fn stagger_call<T, F: Fn() -> Fut, Fut: Future<Output = Result<T>>>(
 pub(crate) mod tests {
     use std::sync::atomic::AtomicUsize;
 
+    use tracing_test::traced_test;
+
     use super::*;
     use crate::defaults::staging::NA_RELAY_HOSTNAME;
     const TIMEOUT: Duration = Duration::from_secs(5);
     const STAGGERING_DELAYS: &[u64] = &[200, 300];
 
     #[tokio::test]
+    #[traced_test]
     async fn test_dns_lookup_ipv4_ipv6() {
-        let _logging = iroh_test::logging::setup();
         let resolver = default_resolver();
         let res: Vec<_> = resolver
             .lookup_ipv4_ipv6_staggered(NA_RELAY_HOSTNAME, TIMEOUT, STAGGERING_DELAYS)
@@ -402,8 +404,8 @@ pub(crate) mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn stagger_basic() {
-        let _logging = iroh_test::logging::setup();
         const CALL_RESULTS: &[Result<u8, u8>] = &[Err(2), Ok(3), Ok(5), Ok(7)];
         static DONE_CALL: AtomicUsize = AtomicUsize::new(0);
         let f = || {

iroh-test/src/logging.rs

@@ -1724,19 +1724,19 @@ mod tests {
 
     use std::time::Instant;
 
-    use iroh_test::CallOnDrop;
     use n0_future::StreamExt;
     use rand::SeedableRng;
     use tracing::{error_span, info, info_span, Instrument};
+    use tracing_test::traced_test;
 
     use super::*;
     use crate::test_utils::{run_relay_server, run_relay_server_with};
 
     const TEST_ALPN: &[u8] = b"n0/iroh/test";
 
     #[tokio::test]
+    #[traced_test]
     async fn test_connect_self() {
-        let _guard = iroh_test::logging::setup();
         let ep = Endpoint::builder()
             .alpns(vec![TEST_ALPN.to_vec()])
             .bind()
@@ -1755,8 +1755,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn endpoint_connect_close() {
-        let _guard = iroh_test::logging::setup();
         let (relay_map, relay_url, _guard) = run_relay_server().await.unwrap();
         let server_secret_key = SecretKey::generate(rand::thread_rng());
         let server_peer_id = server_secret_key.public();
@@ -1849,9 +1849,8 @@ mod tests {
 
     /// Test that peers are properly restored
     #[tokio::test]
+    #[traced_test]
     async fn restore_peers() {
-        let _guard = iroh_test::logging::setup();
-
         let secret_key = SecretKey::generate(rand::thread_rng());
 
         /// Create an endpoint for the test.
@@ -1903,8 +1902,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn endpoint_relay_connect_loop() {
-        let _logging_guard = iroh_test::logging::setup();
         let start = Instant::now();
         let n_clients = 5;
         let n_chunks_per_client = 2;
@@ -1952,10 +1951,6 @@ mod tests {
                 .instrument(error_span!("server")),
             )
         };
-        let abort_handle = server.abort_handle();
-        let _server_guard = CallOnDrop::new(move || {
-            abort_handle.abort();
-        });
 
         for i in 0..n_clients {
             let round_start = Instant::now();
@@ -2010,8 +2005,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn endpoint_bidi_send_recv() {
-        let _logging_guard = iroh_test::logging::setup();
         let ep1 = Endpoint::builder()
             .alpns(vec![TEST_ALPN.to_vec()])
             .relay_mode(RelayMode::Disabled)
@@ -2100,9 +2095,9 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn endpoint_conn_type_stream() {
         const TIMEOUT: Duration = std::time::Duration::from_secs(15);
-        let _logging_guard = iroh_test::logging::setup();
         let (relay_map, _relay_url, _relay_guard) = run_relay_server().await.unwrap();
         let mut rng = rand_chacha::ChaCha8Rng::seed_from_u64(42);
         let ep1_secret_key = SecretKey::generate(&mut rng);
@@ -2166,26 +2161,16 @@ mod tests {
         };
 
         let res_ep1 = tokio::spawn(tokio::time::timeout(TIMEOUT, ep1_side));
-
-        let ep1_abort_handle = res_ep1.abort_handle();
-        let _ep1_guard = CallOnDrop::new(move || {
-            ep1_abort_handle.abort();
-        });
-
         let res_ep2 = tokio::spawn(tokio::time::timeout(TIMEOUT, ep2_side));
-        let ep2_abort_handle = res_ep2.abort_handle();
-        let _ep2_guard = CallOnDrop::new(move || {
-            ep2_abort_handle.abort();
-        });
 
         let (r1, r2) = tokio::try_join!(res_ep1, res_ep2).unwrap();
         r1.expect("ep1 timeout").unwrap();
         r2.expect("ep2 timeout").unwrap();
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_direct_addresses_no_stun_relay() {
-        let _guard = iroh_test::logging::setup();
         let (relay_map, _, _guard) = run_relay_server_with(None, false).await.unwrap();
 
         let ep = Endpoint::builder()

iroh/Cargo.toml

@@ -3138,9 +3138,9 @@ impl NetInfo {
 #[cfg(test)]
 mod tests {
     use anyhow::Context;
-    use iroh_test::CallOnDrop;
     use rand::RngCore;
     use tokio_util::task::AbortOnDropHandle;
+    use tracing_test::traced_test;
 
     use super::*;
     use crate::{
@@ -3214,7 +3214,7 @@ mod tests {
     ///
     /// When the returned drop guard is dropped, the tasks doing this updating are stopped.
     #[instrument(skip_all)]
-    async fn mesh_stacks(stacks: Vec<MagicStack>) -> Result<CallOnDrop> {
+    async fn mesh_stacks(stacks: Vec<MagicStack>) -> Result<JoinSet<()>> {
         /// Registers endpoint addresses of a node to all other nodes.
         fn update_direct_addrs(
             stacks: &[MagicStack],
@@ -3251,9 +3251,6 @@ mod tests {
                 }
             });
         }
-        let guard = CallOnDrop::new(move || {
-            tasks.abort_all();
-        });
 
         // Wait for all nodes to be registered with each other.
         time::timeout(Duration::from_secs(10), async move {
@@ -3278,7 +3275,7 @@ mod tests {
         .await
         .context("failed to connect nodes")?;
         info!("all nodes meshed");
-        Ok(guard)
+        Ok(tasks)
     }
 
     #[instrument(skip_all, fields(me = %ep.endpoint.node_id().fmt_short()))]
@@ -3426,9 +3423,8 @@ mod tests {
     }
 
     #[tokio::test(flavor = "multi_thread")]
+    #[traced_test]
     async fn test_two_devices_roundtrip_quinn_magic() -> Result<()> {
-        iroh_test::logging::setup_multithreaded();
-
         let m1 = MagicStack::new(RelayMode::Disabled).await?;
         let m2 = MagicStack::new(RelayMode::Disabled).await?;
 
@@ -3462,9 +3458,9 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_regression_network_change_rebind_wakes_connection_driver(
     ) -> testresult::TestResult {
-        let _ = iroh_test::logging::setup();
         let m1 = MagicStack::new(RelayMode::Disabled).await?;
         let m2 = MagicStack::new(RelayMode::Disabled).await?;
 
@@ -3501,6 +3497,7 @@ mod tests {
     }
 
     #[tokio::test(flavor = "multi_thread")]
+    #[traced_test]
     async fn test_two_devices_roundtrip_network_change() -> Result<()> {
         time::timeout(
             Duration::from_secs(90),
@@ -3512,8 +3509,6 @@ mod tests {
     /// Same structure as `test_two_devices_roundtrip_quinn_magic`, but interrupts regularly
     /// with (simulated) network changes.
     async fn test_two_devices_roundtrip_network_change_impl() -> Result<()> {
-        iroh_test::logging::setup_multithreaded();
-
         let m1 = MagicStack::new(RelayMode::Disabled).await?;
         let m2 = MagicStack::new(RelayMode::Disabled).await?;
 
@@ -3535,9 +3530,7 @@ mod tests {
                     time::sleep(offset()).await;
                 }
             });
-            CallOnDrop::new(move || {
-                task.abort();
-            })
+            AbortOnDropHandle::new(task)
         };
 
         for i in 0..rounds {
@@ -3564,9 +3557,7 @@ mod tests {
                     time::sleep(offset()).await;
                 }
             });
-            CallOnDrop::new(move || {
-                task.abort();
-            })
+            AbortOnDropHandle::new(task)
         };
 
         for i in 0..rounds {
@@ -3594,9 +3585,7 @@ mod tests {
                 m2.endpoint.magic_sock().force_network_change(true).await;
                 time::sleep(offset()).await;
             });
-            CallOnDrop::new(move || {
-                task.abort();
-            })
+            AbortOnDropHandle::new(task)
         };
 
         for i in 0..rounds {
@@ -3616,8 +3605,8 @@ mod tests {
     }
 
     #[tokio::test(flavor = "multi_thread")]
+    #[traced_test]
     async fn test_two_devices_setup_teardown() -> Result<()> {
-        iroh_test::logging::setup_multithreaded();
         for i in 0..10 {
             println!("-- round {i}");
             println!("setting up magic stack");
@@ -3639,9 +3628,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_two_devices_roundtrip_quinn_raw() -> Result<()> {
-        let _guard = iroh_test::logging::setup();
-
         let make_conn = |addr: SocketAddr| -> anyhow::Result<quinn::Endpoint> {
             let key = SecretKey::generate(rand::thread_rng());
             let conn = std::net::UdpSocket::bind(addr)?;
@@ -3788,9 +3776,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_two_devices_roundtrip_quinn_rebinding_conn() -> Result<()> {
-        let _guard = iroh_test::logging::setup();
-
         fn make_conn(addr: SocketAddr) -> anyhow::Result<quinn::Endpoint> {
             let key = SecretKey::generate(rand::thread_rng());
             let conn = UdpConn::bind(addr)?;
@@ -3981,8 +3968,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_local_endpoints() {
-        let _guard = iroh_test::logging::setup();
         let ms = Handle::new(Default::default()).await.unwrap();
 
         // See if we can get endpoints.
@@ -4105,11 +4092,10 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_try_send_no_send_addr() {
         // Regression test: if there is no send_addr we should keep being able to use the
         // Endpoint.
-        let _guard = iroh_test::logging::setup();
-
         let secret_key_1 = SecretKey::from_bytes(&[1u8; 32]);
         let secret_key_2 = SecretKey::from_bytes(&[2u8; 32]);
         let node_id_2 = secret_key_2.public();
@@ -4196,11 +4182,10 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_try_send_no_udp_addr_or_relay_url() {
         // This specifically tests the `if udp_addr.is_none() && relay_url.is_none()`
         // behaviour of MagicSock::try_send.
-        let _logging_guard = iroh_test::logging::setup();
-
         let secret_key_1 = SecretKey::from_bytes(&[1u8; 32]);
         let secret_key_2 = SecretKey::from_bytes(&[2u8; 32]);
         let node_id_2 = secret_key_2.public();

iroh/src/discovery.rs

@@ -698,6 +698,7 @@ mod tests {
     use std::net::Ipv4Addr;
 
     use iroh_base::SecretKey;
+    use tracing_test::traced_test;
 
     use super::{node_state::MAX_INACTIVE_DIRECT_ADDRESSES, *};
 
@@ -715,9 +716,8 @@ mod tests {
 
     /// Test persisting and loading of known nodes.
     #[tokio::test]
+    #[traced_test]
     async fn restore_from_vec() {
-        let _guard = iroh_test::logging::setup();
-
         let node_map = NodeMap::default();
 
         let mut rng = rand::thread_rng();
@@ -781,9 +781,8 @@ mod tests {
     }
 
     #[test]
+    #[traced_test]
     fn test_prune_direct_addresses() {
-        let _guard = iroh_test::logging::setup();
-
         let node_map = NodeMap::default();
         let public_key = SecretKey::generate(rand::thread_rng()).public();
         let id = node_map

iroh/src/discovery/local_swarm_discovery.rs

@@ -1200,6 +1200,7 @@ mod tests {
     use testresult::TestResult;
     use tokio_util::task::AbortOnDropHandle;
     use tracing::info;
+    use tracing_test::traced_test;
 
     use super::*;
     use crate::test_utils;
@@ -1360,8 +1361,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_active_relay_reconnect() -> TestResult {
-        let _guard = iroh_test::logging::setup();
         let (_relay_map, relay_url, _server) = test_utils::run_relay_server().await?;
         let (peer_node, _echo_node_task) = start_echo_node(relay_url.clone());
 
@@ -1447,8 +1448,8 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_active_relay_inactive() -> TestResult {
-        let _guard = iroh_test::logging::setup();
         let (_relay_map, relay_url, _server) = test_utils::run_relay_server().await?;
 
         let secret_key = SecretKey::from_bytes(&[1u8; 32]);

iroh/src/discovery/pkarr/dht.rs

@@ -136,6 +136,7 @@ mod tests {
     use netwatch::IpFamily;
     use tokio::sync::mpsc;
     use tracing::{info_span, Instrument};
+    use tracing_test::traced_test;
 
     use super::*;
     use crate::tls;
@@ -160,14 +161,14 @@ mod tests {
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_rebinding_conn_send_recv_ipv4() -> Result<()> {
-        let _guard = iroh_test::logging::setup();
         rebinding_conn_send_recv(IpFamily::V4).await
     }
 
     #[tokio::test]
+    #[traced_test]
     async fn test_rebinding_conn_send_recv_ipv6() -> Result<()> {
-        let _guard = iroh_test::logging::setup();
         if !net_report::os_has_ipv6() {
             return Ok(());
         }