diff --git a/Cargo.toml b/Cargo.toml
index a3ea58f0a..e85576fad 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,6 +21,7 @@ rtrb = { version = "0.4", optional = true }
 [dev-dependencies]
 approx = "0.5"
 crossbeam-channel = "0.5"
+test-log = "0.2"
 
 [features]
 default = ["dynamic_loading", "log"]
diff --git a/src/client/async_client.rs b/src/client/async_client.rs
index 04ae96f4e..c3273dedd 100644
--- a/src/client/async_client.rs
+++ b/src/client/async_client.rs
@@ -268,17 +268,17 @@ mod tests {
         assert!(life.upgrade().is_none());
     }
 
-    #[test]
+    #[test_log::test]
     fn activation_failure_detaches_callbacks_and_drops_handlers() {
         check_activation_failure(false);
     }
 
-    #[test]
+    #[test_log::test]
     fn activation_failure_after_start_detaches_callbacks_and_drops_handlers() {
         check_activation_failure(true);
     }
 
-    #[test]
+    #[test_log::test]
     fn dropping_async_client_detaches_callbacks_while_port_keeps_client_alive() {
         let (client, _) = Client::new("", ClientOptions::default()).unwrap();
         let port = client.register_port("input", AudioIn::default()).unwrap();
diff --git a/src/client/callbacks.rs b/src/client/callbacks.rs
index 835c0f63c..511cf542f 100644
--- a/src/client/callbacks.rs
+++ b/src/client/callbacks.rs
@@ -138,6 +138,9 @@ where
             if let Some(ctx) = CallbackContext::<N, P>::from_raw(data) {
                 ctx.mark_invalid(true)
             }
+            #[cfg(feature = "log")]
+            log::error!("{err:?}");
+            #[cfg(not(feature = "log"))]
             eprintln!("{err:?}");
             std::mem::forget(err);
         }
@@ -169,6 +172,9 @@ unsafe extern "C" fn shutdown<N, P>(
             if let Some(ctx) = CallbackContext::<N, P>::from_raw(data) {
                 ctx.mark_invalid(true)
             }
+            #[cfg(feature = "log")]
+            log::error!("{err:?}");
+            #[cfg(not(feature = "log"))]
             eprintln!("{err:?}");
             std::mem::forget(err);
         }
@@ -204,6 +210,9 @@ where
                 if let Some(ctx) = CallbackContext::<N, P>::from_raw(data) {
                     ctx.mark_invalid(true)
                 }
+                #[cfg(feature = "log")]
+                log::error!("JACK process callback panicked.\n{err:?}");
+                #[cfg(not(feature = "log"))]
                 eprintln!("JACK process callback panicked.\n{err:?}");
                 std::mem::forget(err);
                 Control::Quit.to_ffi()
@@ -243,6 +252,9 @@ where
                 if let Some(ctx) = CallbackContext::<N, P>::from_raw(data) {
                     ctx.mark_invalid(true)
                 }
+                #[cfg(feature = "log")]
+                log::error!("{err:?}");
+                #[cfg(not(feature = "log"))]
                 eprintln!("{err:?}");
                 std::mem::forget(err);
                 0
@@ -268,6 +280,9 @@ where
             if let Some(ctx) = CallbackContext::<N, P>::from_raw(data) {
                 ctx.mark_invalid(true)
             }
+            #[cfg(feature = "log")]
+            log::error!("{err:?}");
+            #[cfg(not(feature = "log"))]
             eprintln!("{err:?}");
             std::mem::forget(err);
         }
@@ -302,6 +317,9 @@ where
                 if let Some(ctx) = CallbackContext::<N, P>::from_raw(data) {
                     ctx.mark_invalid(true)
                 }
+                #[cfg(feature = "log")]
+                log::error!("{err:?}");
+                #[cfg(not(feature = "log"))]
                 eprintln!("{err:?}");
                 std::mem::forget(err);
                 Control::Quit.to_ffi()
@@ -332,6 +350,9 @@ where
                 if let Some(ctx) = CallbackContext::<N, P>::from_raw(data) {
                     ctx.mark_invalid(true)
                 }
+                #[cfg(feature = "log")]
+                log::error!("{err:?}");
+                #[cfg(not(feature = "log"))]
                 eprintln!("{err:?}");
                 std::mem::forget(err);
                 Control::Quit.to_ffi()
@@ -362,6 +383,9 @@ unsafe extern "C" fn client_registration<N, P>(
             if let Some(ctx) = CallbackContext::<N, P>::from_raw(data) {
                 ctx.mark_invalid(true)
             }
+            #[cfg(feature = "log")]
+            log::error!("{err:?}");
+            #[cfg(not(feature = "log"))]
             eprintln!("{err:?}");
             std::mem::forget(err);
         }
@@ -399,6 +423,9 @@ unsafe extern "C" fn port_registration<N, P>(
             if let Some(ctx) = CallbackContext::<N, P>::from_raw(data) {
                 ctx.mark_invalid(true)
             }
+            #[cfg(feature = "log")]
+            log::error!("{err:?}");
+            #[cfg(not(feature = "log"))]
             eprintln!("{err:?}");
             std::mem::forget(err);
         }
@@ -437,6 +464,9 @@ where
                 if let Some(ctx) = CallbackContext::<N, P>::from_raw(data) {
                     ctx.mark_invalid(true)
                 }
+                #[cfg(feature = "log")]
+                log::error!("{err:?}");
+                #[cfg(not(feature = "log"))]
                 eprintln!("{err:?}");
                 std::mem::forget(err);
                 Control::Quit.to_ffi()
@@ -467,6 +497,9 @@ unsafe extern "C" fn port_connect<N, P>(
             if let Some(ctx) = CallbackContext::<N, P>::from_raw(data) {
                 ctx.mark_invalid(true)
             }
+            #[cfg(feature = "log")]
+            log::error!("{err:?}");
+            #[cfg(not(feature = "log"))]
             eprintln!("{err:?}");
             std::mem::forget(err);
         }
@@ -495,6 +528,9 @@ where
                 if let Some(ctx) = CallbackContext::<N, P>::from_raw(data) {
                     ctx.mark_invalid(true)
                 }
+                #[cfg(feature = "log")]
+                log::error!("{err:?}");
+                #[cfg(not(feature = "log"))]
                 eprintln!("{err:?}");
                 std::mem::forget(err);
                 Control::Quit.to_ffi()
@@ -525,6 +561,9 @@ where
                 if let Some(ctx) = CallbackContext::<N, P>::from_raw(data) {
                     ctx.mark_invalid(true)
                 }
+                #[cfg(feature = "log")]
+                log::error!("{err:?}");
+                #[cfg(not(feature = "log"))]
                 eprintln!("{err:?}");
                 std::mem::forget(err);
                 Control::Quit.to_ffi()
diff --git a/src/client/client_impl.rs b/src/client/client_impl.rs
index c2cab1d12..6fd17828d 100644
--- a/src/client/client_impl.rs
+++ b/src/client/client_impl.rs
@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use std::fmt::Debug;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex, Weak};
-use std::{ffi, fmt, ptr};
+use std::{ffi, fmt};
 
 use crate::client::common::CREATE_OR_DESTROY_CLIENT_MUTEX;
 use crate::jack_enums::CodeOrMessage;
@@ -868,11 +868,12 @@ impl Client {
 impl Drop for ClientHandle {
     fn drop(&mut self) {
         let _m = CREATE_OR_DESTROY_CLIENT_MUTEX.lock().ok();
-        // Rep invariant.
-        debug_assert!(!self.client_ptr.is_null());
+        let ptr = std::mem::take(&mut self.client_ptr);
+        if ptr.is_null() {
+            return;
+        }
         // Best effort close client.
-        let _res = unsafe { j::jack_client_close(self.client_ptr) };
-        self.client_ptr = ptr::null_mut();
+        let _res = unsafe { j::jack_client_close(ptr) };
     }
 }
 
@@ -989,9 +990,10 @@ pub struct CycleTimes {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::ptr;
     use std::sync::atomic::{AtomicBool, Ordering};
 
-    #[test]
+    #[test_log::test]
     fn removed_port_state_survives_handle_drops_and_pruning() {
         let (client, _) = Client::new("", Default::default()).unwrap();
         let handle = client.handle();
@@ -1018,7 +1020,7 @@ mod tests {
         assert!(!handle.get_or_create_port_state(untracked_key).is_valid());
     }
 
-    #[test]
+    #[test_log::test]
     fn registration_at_the_same_pointer_preserves_old_invalidation() {
         let (client, _) = Client::new("", Default::default()).unwrap();
         let handle = client.handle();
@@ -1048,7 +1050,7 @@ mod tests {
         }
     }
 
-    #[test]
+    #[test_log::test]
     fn property_handler_lives_until_client_handle_closes() {
         let (mut client, _) = Client::new("", Default::default()).unwrap();
         // Registration must also work after other owners have been created.
diff --git a/src/port/midi.rs b/src/port/midi.rs
index 26b7bb254..1a0627734 100644
--- a/src/port/midi.rs
+++ b/src/port/midi.rs
@@ -248,7 +248,7 @@ mod tests {
         }
     }
 
-    #[test]
+    #[test_log::test]
     fn empty_iter_has_no_events() {
         let mut iter = empty_iter();
         assert_eq!(iter.size_hint(), (0, Some(0)));
@@ -258,7 +258,7 @@ mod tests {
         assert_eq!(iter.last(), None);
     }
 
-    #[test]
+    #[test_log::test]
     fn nth_past_the_end_does_not_underflow() {
         let mut iter = empty_iter();
         assert_eq!(iter.nth(5), None);
@@ -268,7 +268,7 @@ mod tests {
         assert_eq!(iter.size_hint(), (0, Some(0)));
     }
 
-    #[test]
+    #[test_log::test]
     fn next_past_the_end_does_not_underflow() {
         let mut iter = empty_iter();
         for _ in 0..3 {
diff --git a/src/port/port_impl.rs b/src/port/port_impl.rs
index 8af317e2f..b4d853928 100644
--- a/src/port/port_impl.rs
+++ b/src/port/port_impl.rs
@@ -544,7 +544,7 @@ mod tests {
         }
     }
 
-    #[test]
+    #[test_log::test]
     fn ports_keep_client_alive_until_last_port_is_dropped() {
         let (client, _) = Client::new("", Default::default()).unwrap();
         let port = client
@@ -571,7 +571,7 @@ mod tests {
         assert!(life.upgrade().is_none());
     }
 
-    #[test]
+    #[test_log::test]
     fn unregistering_a_port_invalidates_every_handle_to_it() {
         let (client, _) = Client::new("", Default::default()).unwrap();
         let port = client.register_port("p", AudioIn::default()).unwrap();
@@ -600,7 +600,7 @@ mod tests {
         );
     }
 
-    #[test]
+    #[test_log::test]
     fn reregistering_a_port_name_gives_a_fresh_valid_port() {
         let (client, _) = Client::new("", Default::default()).unwrap();
         let port = client.register_port("p", AudioIn::default()).unwrap();
@@ -616,7 +616,7 @@ mod tests {
         );
     }
 
-    #[test]
+    #[test_log::test]
     fn removed_port_lookups_stay_absent_after_all_handles_are_dropped() {
         let (client, _) = Client::new("", Default::default()).unwrap();
         let name = format!("{}:p", client.name());
@@ -658,7 +658,7 @@ mod tests {
         assert!(client.port_by_name(&name).is_none());
     }
 
-    #[test]
+    #[test_log::test]
     fn failing_to_unregister_a_foreign_port_leaves_it_valid() {
         let (owner, _) = Client::new("", Default::default()).unwrap();
         let (other, _) = Client::new("", Default::default()).unwrap();
@@ -678,7 +678,7 @@ mod tests {
         assert_eq!(kept.name(), Ok(name));
     }
 
-    #[test]
+    #[test_log::test]
     fn active_client_detects_foreign_port_unregistration_and_reregistration() {
         let (owner, _) = Client::new("", Default::default()).unwrap();
         let name = format!("{}:p", owner.name());
@@ -736,7 +736,7 @@ mod tests {
         assert!(!foreign.is_valid());
     }
 
-    #[test]
+    #[test_log::test]
     fn dangling_ports_have_no_buffers() {
         let (client, _) = Client::new("", Default::default()).unwrap();
         let audio_in = client.register_port("in", AudioIn::default()).unwrap();
diff --git a/src/properties.rs b/src/properties.rs
index f5c57f26c..50b34246a 100644
--- a/src/properties.rs
+++ b/src/properties.rs
@@ -13,6 +13,7 @@ use jack_sys as j;
 /// properties of `subject` were removed (see [`Client::property_remove_subject`]), or when all
 /// properties of all subjects were removed (see [`Client::property_remove_all`]), in which case
 /// `subject` is the empty UUID `0`.
+/// Both null and empty keys from JACK are represented as `None`.
 ///
 /// Non-UTF-8 keys are converted lossily, invalid bytes are replaced with `U+FFFD`.
 ///
@@ -54,12 +55,12 @@ pub(crate) unsafe extern "C" fn property_changed<P>(
     unsafe {
         let res = catch_unwind(|| {
             let h: &mut P = &mut *(arg as *mut P);
-            // JACK passes a NULL key when all properties of a subject (or of all subjects) were
-            // deleted.
+            // JACK can report bulk changes with either a NULL key or an empty string.
             let key = if key.is_null() {
                 None
             } else {
-                Some(std::ffi::CStr::from_ptr(key).to_string_lossy())
+                let key = std::ffi::CStr::from_ptr(key).to_string_lossy();
+                if key.is_empty() { None } else { Some(key) }
             };
             let c = match change {
                 j::PropertyCreated => PropertyChange::Created { subject, key },
@@ -74,6 +75,9 @@ pub(crate) unsafe extern "C" fn property_changed<P>(
                 .copied()
                 .or_else(|| err.downcast_ref::<String>().map(String::as_str))
                 .unwrap_or("unknown panic");
+            #[cfg(feature = "log")]
+            log::error!("panic in property change handler: {msg}");
+            #[cfg(not(feature = "log"))]
             eprintln!("panic in property change handler: {msg}");
             std::mem::forget(err);
         }
@@ -403,7 +407,7 @@ mod metadata {
         use crate::client::{Client, ClientOptions};
         use std::sync::mpsc::{Sender, channel};
 
-        #[test]
+        #[test_log::test]
         fn can_set_and_get() {
             let (c, _) = Client::new("dummy", ClientOptions::default()).unwrap();
 
@@ -442,7 +446,7 @@ mod metadata {
             assert_eq!(sub.get("asdf"), None);
         }
 
-        #[test]
+        #[test_log::test]
         fn property_get_subject_without_properties_is_empty() {
             let (c, _) = Client::new("", ClientOptions::default()).unwrap();
             // A subject that was never given any properties. Fill the stack with junk first so that
@@ -457,7 +461,7 @@ mod metadata {
             }
         }
 
-        #[test]
+        #[test_log::test]
         fn non_utf8_properties_do_not_panic() {
             let (c, _) = Client::new("non_utf8", ClientOptions::default()).unwrap();
             let key = ffi::CString::new(&b"non-utf8-key-\xff"[..]).unwrap();
@@ -490,7 +494,7 @@ mod metadata {
             unsafe { j::jack_remove_property(c.raw(), c.uuid(), key.as_ptr()) };
         }
 
-        #[test]
+        #[test_log::test]
         #[ignore = "unsupported on pipewire-jack; CI runs ignored tests with JACK2"]
         fn can_remove() {
             let (c1, _) = Client::new("client1", ClientOptions::default()).unwrap();
@@ -541,7 +545,7 @@ mod metadata {
             assert_eq!(Ok(()), c1.property_remove_subject(c1.uuid()));
         }
 
-        #[test]
+        #[test_log::test]
         #[ignore = "unsupported on pipewire-jack; CI runs ignored tests with JACK2"]
         fn can_property_remove_all() {
             let (c, _) = Client::new("dummy", ClientOptions::default()).unwrap();
@@ -564,7 +568,7 @@ mod metadata {
             assert_eq!(0, all.len());
         }
 
-        #[test]
+        #[test_log::test]
         #[ignore = "unsupported on pipewire-jack; CI runs ignored tests with JACK2"]
         fn client_callbacks() {
             let timeout = std::time::Duration::from_millis(50);
@@ -673,7 +677,7 @@ mod metadata {
             receiver.iter().collect()
         }
 
-        #[test]
+        #[test_log::test]
         fn property_changed_null_key() {
             assert_eq!(
                 call_property_changed(ptr::null(), j::PropertyDeleted),
@@ -684,7 +688,18 @@ mod metadata {
             );
         }
 
-        #[test]
+        #[test_log::test]
+        fn property_changed_empty_key() {
+            assert_eq!(
+                call_property_changed(c"".as_ptr(), j::PropertyDeleted),
+                vec![PropertyChangeOwned::Deleted {
+                    subject: 42,
+                    key: None
+                }]
+            );
+        }
+
+        #[test_log::test]
         fn property_changed_non_utf8_key() {
             let key = ffi::CString::new(&b"key-\xff"[..]).unwrap();
             assert_eq!(
@@ -696,7 +711,7 @@ mod metadata {
             );
         }
 
-        #[test]
+        #[test_log::test]
         #[ignore = "unsupported on pipewire-jack; CI runs ignored tests with JACK2"]
         fn client_callbacks_remove_subject_and_all() {
             let timeout = std::time::Duration::from_millis(50);
@@ -734,7 +749,7 @@ mod metadata {
             ));
         }
 
-        #[test]
+        #[test_log::test]
         #[should_panic]
         fn double_register() {
             let (mut c, _) = Client::new("client1", ClientOptions::default()).unwrap();
diff --git a/src/tests/client.rs b/src/tests/client.rs
index 4b4dab141..f41feb271 100644
--- a/src/tests/client.rs
+++ b/src/tests/client.rs
@@ -1,6 +1,6 @@
 use crate::{Error::InteriorNul, tests::DEFAULT_TEST_CLIENT};
 
-#[test]
+#[test_log::test]
 fn client_can_open() {
     let (client, status) =
         crate::Client::new("my new client", crate::ClientOptions::default()).unwrap();
@@ -14,7 +14,7 @@ fn client_can_open() {
     assert!(cpu_load >= 0.0, "client.cpu_load() = {}", cpu_load);
 }
 
-#[test]
+#[test_log::test]
 fn client_new_rejects_options_that_need_extra_arguments() {
     for flag in [
         crate::ClientOptions::SERVER_NAME,
@@ -28,7 +28,7 @@ fn client_new_rejects_options_that_need_extra_arguments() {
     }
 }
 
-#[test]
+#[test_log::test]
 fn client_can_open_with_server_name() {
     let (client, _) = crate::Client::new_with_server_name(
         "server name client",
@@ -47,7 +47,7 @@ fn client_can_open_with_server_name() {
     .unwrap();
 }
 
-#[test]
+#[test_log::test]
 fn client_with_server_name_rejects_other_options_that_need_extra_arguments() {
     for flag in [
         crate::ClientOptions::LOAD_NAME,
@@ -61,7 +61,7 @@ fn client_with_server_name_rejects_other_options_that_need_extra_arguments() {
     }
 }
 
-#[test]
+#[test_log::test]
 fn time_is_montonically_increasing() {
     let (client, _) = crate::Client::new("", crate::ClientOptions::default()).unwrap();
     let ac = client.activate_async((), ()).unwrap();
@@ -76,7 +76,7 @@ fn time_is_montonically_increasing() {
     assert_ne!(client.frame_time(), frame_time0);
 }
 
-#[test]
+#[test_log::test]
 #[ignore = "unsupported on pipewire-jack; CI runs ignored tests with JACK2"]
 fn maybe_client_can_set_buffer_size() {
     let initial_buffer_size = DEFAULT_TEST_CLIENT.buffer_size();
@@ -90,7 +90,7 @@ fn maybe_client_can_set_buffer_size() {
         .unwrap();
 }
 
-#[test]
+#[test_log::test]
 fn client_uuid_are_unique() {
     let (client1, _) = crate::Client::new("", crate::ClientOptions::default()).unwrap();
     let (client2, _) = crate::Client::new("", crate::ClientOptions::default()).unwrap();
@@ -102,7 +102,7 @@ fn client_uuid_are_unique() {
     assert_ne!(client1.uuid(), client2.uuid());
 }
 
-#[test]
+#[test_log::test]
 fn uuid_can_map_to_client_name() {
     let (client1, _) =
         crate::Client::new("uuid-client-1", crate::ClientOptions::default()).unwrap();
@@ -127,7 +127,7 @@ fn uuid_can_map_to_client_name() {
     );
 }
 
-#[test]
+#[test_log::test]
 fn nonexistant_uuid_to_client_name_returns_none() {
     let (client, _) =
         crate::Client::new("dropped-client", crate::ClientOptions::default()).unwrap();
@@ -138,7 +138,7 @@ fn nonexistant_uuid_to_client_name_returns_none() {
     assert_eq!(DEFAULT_TEST_CLIENT.name_by_uuid(uuid), None);
 }
 
-#[test]
+#[test_log::test]
 fn unregistering_another_clients_port_is_an_unregistration_error() {
     let (owner, _) = crate::Client::new("", crate::ClientOptions::default()).unwrap();
     let (other, _) = crate::Client::new("", crate::ClientOptions::default()).unwrap();
@@ -153,7 +153,7 @@ fn unregistering_another_clients_port_is_an_unregistration_error() {
     );
 }
 
-#[test]
+#[test_log::test]
 fn registering_an_unowned_port_is_an_error() {
     let (client, _) = crate::Client::new("", crate::ClientOptions::default()).unwrap();
     assert_eq!(
@@ -162,7 +162,7 @@ fn registering_an_unowned_port_is_an_error() {
     );
 }
 
-#[test]
+#[test_log::test]
 fn client_with_unknown_server_name_fails_to_open() {
     // Proves the server name actually reaches JACK, rather than being dropped.
     let err = crate::Client::new_with_server_name(
@@ -190,7 +190,7 @@ fn open_non_utf8_client(name: &[u8]) -> crate::Client {
     unsafe { crate::Client::from_raw(ptr) }
 }
 
-#[test]
+#[test_log::test]
 fn non_utf8_client_name_is_decoded_lossily() {
     let client = open_non_utf8_client(b"non-utf8-\xff");
     assert_eq!(client.name(), "non-utf8-\u{fffd}");
@@ -200,7 +200,7 @@ fn non_utf8_client_name_is_decoded_lossily() {
     );
 }
 
-#[test]
+#[test_log::test]
 fn non_utf8_client_registration_does_not_stop_processing() {
     use std::sync::atomic::{AtomicUsize, Ordering};
     use std::sync::{Arc, Mutex};
@@ -243,7 +243,7 @@ fn non_utf8_client_registration_does_not_stop_processing() {
     ac.deactivate().unwrap();
 }
 
-#[test]
+#[test_log::test]
 fn client_open_rejects_interior_nul() {
     let nul = "a\0b";
     let options = crate::ClientOptions::default();
@@ -257,7 +257,7 @@ fn client_open_rejects_interior_nul() {
     );
 }
 
-#[test]
+#[test_log::test]
 fn client_methods_reject_interior_nul() {
     let nul = "a\0b";
     let client = &*DEFAULT_TEST_CLIENT;
@@ -287,7 +287,7 @@ fn client_methods_reject_interior_nul() {
     );
 }
 
-#[test]
+#[test_log::test]
 fn property_methods_reject_interior_nul() {
     let nul = "a\0b";
     let client = &*DEFAULT_TEST_CLIENT;
@@ -304,7 +304,7 @@ fn property_methods_reject_interior_nul() {
     );
 }
 
-#[test]
+#[test_log::test]
 fn lookups_with_interior_nul_find_nothing() {
     let nul = "a\0b";
     let client = &*DEFAULT_TEST_CLIENT;
@@ -317,7 +317,7 @@ fn lookups_with_interior_nul_find_nothing() {
     assert!(client.ports(None, Some(nul), flags).is_empty());
 }
 
-#[test]
+#[test_log::test]
 fn port_methods_reject_interior_nul() {
     let nul = "a\0b";
     let (client, _) = crate::Client::new("", crate::ClientOptions::default()).unwrap();
diff --git a/src/tests/log.rs b/src/tests/log.rs
index e3a82b192..9d4fb8ba3 100644
--- a/src/tests/log.rs
+++ b/src/tests/log.rs
@@ -1,7 +1,7 @@
 unsafe extern "C" fn test_info_callback(_msg: *const libc::c_char) {}
 unsafe extern "C" fn test_error_callback(_msg: *const libc::c_char) {}
 
-#[test]
+#[test_log::test]
 fn can_set_logger() {
     // TODO: This passes on JACK2 1.9.22, but not 1.9.20 which is used in the GitHub runners.
     std::panic::catch_unwind(|| {
diff --git a/src/tests/processing.rs b/src/tests/processing.rs
index ed6ccf33e..b1d3a8f74 100644
--- a/src/tests/processing.rs
+++ b/src/tests/processing.rs
@@ -1,4 +1,4 @@
-#[test]
+#[test_log::test]
 fn panic_in_process_handler_propagates_as_error_in_deactivate() {
     let (client, _) = crate::Client::new("", crate::ClientOptions::default()).unwrap();
     let (send, recv) = std::sync::mpsc::sync_channel(1);
@@ -14,17 +14,17 @@ fn panic_in_process_handler_propagates_as_error_in_deactivate() {
     assert_eq!(ac.deactivate().err(), Some(crate::Error::ClientPanicked));
 }
 
-#[test]
+#[test_log::test]
 fn panic_in_buffer_size_handler_propagates_as_error_in_deactivate() {
     let (client, _) = crate::Client::new("", crate::ClientOptions::default()).unwrap();
     let (send, recv) = std::sync::mpsc::sync_channel(2);
     let handler = crate::contrib::ClosureProcessHandler::with_state(
         (),
+        |_, _, _| panic!("buffer_size panicked, so process should not be called"),
         move |_, _, _| {
             send.try_send(true).unwrap();
             panic!("intentional panic here");
         },
-        move |_, _, _| crate::Control::Continue,
     );
     let ac = client.activate_async((), handler).unwrap();
     assert!(
@@ -34,22 +34,18 @@ fn panic_in_buffer_size_handler_propagates_as_error_in_deactivate() {
     assert_eq!(ac.deactivate().err(), Some(crate::Error::ClientPanicked));
 }
 
-#[test]
+#[test_log::test]
 fn quitting_stops_calling_process() {
-    eprintln!("Creating client.");
     let (client, _) = crate::Client::new("", crate::ClientOptions::default()).unwrap();
     let mut calls = 0;
     let (send, recv) = std::sync::mpsc::sync_channel(2);
-    eprintln!("Creating callback.");
     let process_handler = crate::contrib::ClosureProcessHandler::new(move |_, _| {
         send.try_send(true).unwrap();
         calls += 1;
         assert_eq!(calls, 1);
         crate::Control::Quit
     });
-    eprintln!("Activating client.");
     let ac = client.activate_async((), process_handler).unwrap();
-    eprintln!("Waiting for async response.");
     assert!(
         recv.recv_timeout(std::time::Duration::from_secs(1))
             .unwrap()
@@ -57,7 +53,7 @@ fn quitting_stops_calling_process() {
     ac.deactivate().unwrap();
 }
 
-#[test]
+#[test_log::test]
 fn quitting_buffer_size_never_runs_process() {
     // JACK calls `buffer_size` once before the first `process`. If it quits, `process` must never
     // be called.
@@ -81,7 +77,7 @@ fn quitting_buffer_size_never_runs_process() {
     ac.deactivate().unwrap();
 }
 
-#[test]
+#[test_log::test]
 fn buffer_size_is_called_before_process() {
     let (client, _) = crate::Client::new("", crate::ClientOptions::default()).unwrap();
     let (send, recv) = std::sync::mpsc::sync_channel(2);
@@ -108,7 +104,7 @@ fn buffer_size_is_called_before_process() {
     assert_eq!(ac.deactivate().unwrap().2.state, "processing");
 }
 
-#[test]
+#[test_log::test]
 fn signals_in_audio_ports_are_forwarded() {
     // Setup clients and ports.
     let (client, _) = crate::Client::new("", crate::ClientOptions::default()).unwrap();
@@ -153,7 +149,7 @@ fn signals_in_audio_ports_are_forwarded() {
     ac.deactivate().unwrap();
 }
 
-#[test]
+#[test_log::test]
 fn messages_in_midi_ports_are_forwarded() {
     let (client, _) = crate::Client::new("", crate::ClientOptions::default()).unwrap();
 
@@ -203,7 +199,7 @@ fn messages_in_midi_ports_are_forwarded() {
     ac.deactivate().unwrap();
 }
 
-#[test]
+#[test_log::test]
 fn activating_client_notifies_buffer_size_before_beginning() {
     let (client, _) = crate::Client::new("", crate::ClientOptions::default()).unwrap();
     let initial_buffer_size = client.buffer_size() as usize;
diff --git a/src/tests/ringbuffer.rs b/src/tests/ringbuffer.rs
index 2dd24b69a..c298abf4d 100644
--- a/src/tests/ringbuffer.rs
+++ b/src/tests/ringbuffer.rs
@@ -1,11 +1,11 @@
 use crate::RingBuffer;
 
-#[test]
+#[test_log::test]
 fn ringbuffer_new_creates_new_ringbuffer() {
     RingBuffer::new(1024).unwrap();
 }
 
-#[test]
+#[test_log::test]
 fn advancing_transfers_space_from_writer_to_reader() {
     let ringbuf = RingBuffer::new(1024).unwrap();
     let (reader, mut writer) = ringbuf.into_reader_writer();
@@ -18,7 +18,7 @@ fn advancing_transfers_space_from_writer_to_reader() {
     assert_eq!(reader.space(), 23);
 }
 
-#[test]
+#[test_log::test]
 fn writing_to_writer_sends_to_reader() {
     let ringbuf = RingBuffer::new(1024).unwrap();
     let (mut reader, mut writer) = ringbuf.into_reader_writer();
@@ -29,7 +29,7 @@ fn writing_to_writer_sends_to_reader() {
     assert_eq!(reader.read_slice(&mut tmp_buffer), &[0, 1, 2, 3]);
 }
 
-#[test]
+#[test_log::test]
 fn written_bytes_can_be_peaked() {
     let ringbuf = RingBuffer::new(1024).unwrap();
     let (reader, mut writer) = ringbuf.into_reader_writer();
@@ -41,7 +41,7 @@ fn written_bytes_can_be_peaked() {
     );
 }
 
-#[test]
+#[test_log::test]
 fn advancing_and_writing_shifts_vector() {
     let ringbuf = RingBuffer::new(8).unwrap();
     let (mut reader, mut writer) = ringbuf.into_reader_writer();
@@ -64,7 +64,7 @@ fn advancing_and_writing_shifts_vector() {
     assert_eq!(reader.peek_iter().copied().collect::<Vec<_>>(), &[0, 1, 2]);
 }
 
-#[test]
+#[test_log::test]
 fn writing_and_advancing_produces_data_on_reader() {
     let ringbuf = RingBuffer::new(1024).unwrap();
     let (mut reader, mut writer) = ringbuf.into_reader_writer();
@@ -76,7 +76,7 @@ fn writing_and_advancing_produces_data_on_reader() {
     assert_eq!(reader.read_slice(&mut [0; 8]), &[0, 1, 2, 3]);
 }
 
-#[test]
+#[test_log::test]
 fn reading_and_writing_from_separate_threads_is_ok() {
     let ringbuf = RingBuffer::new(1024).unwrap();
     let (mut reader, mut writer) = ringbuf.into_reader_writer();
diff --git a/src/tests/time.rs b/src/tests/time.rs
index 42ac2c3e4..8d5b9d423 100644
--- a/src/tests/time.rs
+++ b/src/tests/time.rs
@@ -19,7 +19,7 @@ fn active_client() -> crate::AsyncClient<(), impl crate::ProcessHandler> {
     ac
 }
 
-#[test]
+#[test_log::test]
 fn frame_and_time_are_convertable() {
     let ac = active_client();
     let client = ac.as_client();
@@ -31,7 +31,7 @@ fn frame_and_time_are_convertable() {
     );
 }
 
-#[test]
+#[test_log::test]
 fn one_frame_duration_is_inverse_of_sample_rate() {
     let ac = active_client();
     let client = ac.as_client();
@@ -43,7 +43,7 @@ fn one_frame_duration_is_inverse_of_sample_rate() {
     );
 }
 
-#[test]
+#[test_log::test]
 fn one_second_is_sample_rate_frames() {
     let ac = active_client();
     let client = ac.as_client();
diff --git a/src/tests/transport.rs b/src/tests/transport.rs
index aa7779c3d..05ea86b92 100644
--- a/src/tests/transport.rs
+++ b/src/tests/transport.rs
@@ -5,7 +5,7 @@ use std::{
 
 use crate::{Client, TransportPosition, TransportState};
 
-#[test]
+#[test_log::test]
 fn new_transport_is_not_valid() {
     assert!(!TransportPosition::default().valid_bbt());
     assert!(!TransportPosition::default().valid_bbt_frame_offset());
@@ -16,7 +16,7 @@ fn new_transport_is_not_valid() {
     assert_eq!(TransportPosition::default().usecs(), None);
 }
 
-#[test]
+#[test_log::test]
 fn starting_transport_sets_state_to_started() {
     let (client, _) = Client::new("", Default::default()).unwrap();
     let ac = client.activate_async((), ()).unwrap();
diff --git a/src/transport.rs b/src/transport.rs
index 00c3726f6..fbea3cd39 100644
--- a/src/transport.rs
+++ b/src/transport.rs
@@ -483,7 +483,7 @@ mod tests {
     use super::*;
     use crate::Client;
 
-    #[test]
+    #[test_log::test]
     fn transport_keeps_client_alive_until_dropped() {
         let (client, _) = Client::new("", Default::default()).unwrap();
         let transport = client.transport();
@@ -500,7 +500,7 @@ mod tests {
         assert!(life.upgrade().is_none());
     }
 
-    #[test]
+    #[test_log::test]
     fn bbt_validation_rejects_non_finite_values() {
         use TransportBBTValidationError::*;
         assert_eq!(