diff --git a/examples/cpp17_intro.cpp b/examples/cpp17_intro.cpp
index 33c091f3..f482d306 100644
--- a/examples/cpp17_intro.cpp
+++ b/examples/cpp17_intro.cpp
@@ -7,6 +7,7 @@
 #include <iostream>
 #include <boost/redis/run.hpp>
 #include <boost/redis/address.hpp>
+#include <boost/redis/logger.hpp>
 #include <boost/redis/src.hpp>
 
 namespace net = boost::asio;
@@ -15,6 +16,7 @@ using boost::redis::request;
 using boost::redis::response;
 using boost::redis::ignore_t;
 using boost::redis::async_run;
+using boost::redis::logger;
 using boost::redis::address;
 using namespace std::chrono_literals;
 
@@ -39,7 +41,7 @@ auto main(int argc, char * argv[]) -> int
       net::io_context ioc;
       connection conn{ioc};
 
-      async_run(conn, addr, 10s, 10s, [&](auto){
+      async_run(conn, addr, 10s, 10s, logger{}, [&](auto){
          conn.cancel();
       });
 
diff --git a/examples/cpp17_intro_sync.cpp b/examples/cpp17_intro_sync.cpp
index f204da8c..20aff7ef 100644
--- a/examples/cpp17_intro_sync.cpp
+++ b/examples/cpp17_intro_sync.cpp
@@ -8,6 +8,7 @@
 #include <boost/redis/request.hpp>
 #include <boost/redis/check_health.hpp>
 #include <boost/redis/run.hpp>
+#include <boost/redis/logger.hpp>
 #include <boost/asio/deferred.hpp>
 #include <boost/asio/use_future.hpp>
 #include <tuple>
@@ -27,6 +28,7 @@ using boost::redis::response;
 using boost::redis::ignore_t;
 using boost::redis::async_run;
 using boost::redis::address;
+using boost::redis::logger;
 using boost::redis::async_check_health;
 using namespace std::chrono_literals;
 
@@ -56,7 +58,7 @@ auto main(int argc, char * argv[]) -> int
       // Starts a thread that will can io_context::run on which the
       // connection will run.
       std::thread t{[&ioc, conn, addr]() {
-         async_run(*conn, addr, 10s, 10s, [conn](auto){
+         async_run(*conn, addr, 10s, 10s, logger{}, [conn](auto){
             conn->cancel();
          });
 
diff --git a/examples/cpp20_subscriber.cpp b/examples/cpp20_subscriber.cpp
index b09fd85c..a403dcc1 100644
--- a/examples/cpp20_subscriber.cpp
+++ b/examples/cpp20_subscriber.cpp
@@ -4,24 +4,25 @@
  * accompanying file LICENSE.txt)
  */
 
-#include <boost/redis/run.hpp>
-#include <boost/redis/check_health.hpp>
+#include <boost/redis/experimental/connector.hpp>
+#include <boost/redis/logger.hpp>
 #include <boost/asio/awaitable.hpp>
+#include <boost/asio/detached.hpp>
 #include <boost/asio/use_awaitable.hpp>
+#include <boost/asio/co_spawn.hpp>
+#include <boost/asio/consign.hpp>
 #include <iostream>
 
 #if defined(BOOST_ASIO_HAS_CO_AWAIT)
-#include <boost/asio/experimental/awaitable_operators.hpp>
 
 namespace net = boost::asio;
-using namespace net::experimental::awaitable_operators;
-using steady_timer = net::use_awaitable_t<>::as_default_on_t<net::steady_timer>;
-using boost::redis::request;
-using boost::redis::async_run;
-using boost::redis::generic_response;
-using boost::redis::async_check_health;
-using boost::redis::address;
-using connection = net::use_awaitable_t<>::as_default_on_t<boost::redis::connection>;
+namespace redis = boost::redis;
+using redis::generic_response;
+using redis::address;
+using redis::logger;
+using redis::experimental::async_connect;
+using redis::experimental::connect_config;
+using connection = net::use_awaitable_t<>::as_default_on_t<redis::connection>;
 
 /* This example will subscribe and read pushes indefinitely.
  *
@@ -39,12 +40,16 @@ using connection = net::use_awaitable_t<>::as_default_on_t<boost::redis::connect
  * > CLIENT kill TYPE pubsub
  */
 
-// Receives pushes.
+// Receives server pushes.
 auto receiver(std::shared_ptr<connection> conn) -> net::awaitable<void>
 {
    for (generic_response resp;;) {
       co_await conn->async_receive(resp);
-      std::cout << resp.value().at(1).value << " " << resp.value().at(2).value << " " << resp.value().at(3).value << std::endl;
+      std::cout
+         << resp.value().at(1).value
+         << " " << resp.value().at(2).value
+         << " " << resp.value().at(3).value
+         << std::endl;
       resp.value().clear();
    }
 }
@@ -53,19 +58,10 @@ auto co_main(address const& addr) -> net::awaitable<void>
 {
    auto ex = co_await net::this_coro::executor;
    auto conn = std::make_shared<connection>(ex);
-   steady_timer timer{ex};
-
-   request req;
-   req.push("HELLO", 3);
-   req.push("SUBSCRIBE", "channel");
-
-   // The loop will reconnect on connection lost. To exit type Ctrl-C twice.
-   for (;;) {
-      co_await ((async_run(*conn, addr) || async_check_health(*conn) || receiver(conn)) && conn->async_exec(req));
-      conn->reset_stream();
-      timer.expires_after(std::chrono::seconds{1});
-      co_await timer.async_wait();
-   }
+   connect_config cfg;
+   cfg.addr = addr;
+   net::co_spawn(ex, receiver(conn), net::detached);
+   redis::experimental::async_connect(*conn, cfg, logger{}, net::consign(net::detached, conn));
 }
 
 #endif // defined(BOOST_ASIO_HAS_CO_AWAIT)
diff --git a/include/boost/redis/check_health.hpp b/include/boost/redis/check_health.hpp
index 63d6a925..f76efc83 100644
--- a/include/boost/redis/check_health.hpp
+++ b/include/boost/redis/check_health.hpp
@@ -38,7 +38,7 @@ public:
       {
          checker->prom_.emplace(conn->async_exec(checker->req_, checker->resp_, asio::experimental::use_promise));
 
-         checker->timer_.expires_after(checker->interval_);
+         checker->timer_.expires_after(checker->timeout_);
          BOOST_ASIO_CORO_YIELD
          checker->timer_.async_wait(std::move(self));
          if (ec || is_cancelled(self) || checker->resp_.value().empty()) {
@@ -70,7 +70,7 @@ public:
       std::string const& msg,
       std::chrono::steady_clock::duration interval)
    : timer_{ex}
-   , interval_{interval}
+   , timeout_{interval}
    {
       req_.push("PING", msg);
    }
@@ -93,13 +93,20 @@ public:
       prom_.reset();
    }
 
+   void cancel()
+   {
+      timer_.cancel();
+      if (prom_)
+         prom_.cancel();
+   }
+
 private:
    template <class, class> friend class check_health_op;
    timer_type timer_;
    std::optional<promise_type> prom_;
    redis::request req_;
    redis::generic_response resp_;
-   std::chrono::steady_clock::duration interval_;
+   std::chrono::steady_clock::duration timeout_;
 };
 
 } // detail
diff --git a/include/boost/redis/detail/runner.hpp b/include/boost/redis/detail/runner.hpp
index b571efb9..6a86d219 100644
--- a/include/boost/redis/detail/runner.hpp
+++ b/include/boost/redis/detail/runner.hpp
@@ -48,6 +48,8 @@ struct resolve_op {
             asio::experimental::wait_for_one(),
             std::move(self));
 
+         runner->logger_.on_resolve(ec1, res);
+
          if (is_cancelled(self)) {
             self.complete(asio::error::operation_aborted);
             return;
@@ -86,10 +88,10 @@ struct connect_op {
 
    template <class Self>
    void operator()( Self& self
-                  , std::array<std::size_t, 2> order = {}
-                  , system::error_code ec1 = {}
-                  , asio::ip::tcp::endpoint const& = {}
-                  , system::error_code ec2 = {})
+                  , std::array<std::size_t, 2> const& order = {}
+                  , system::error_code const& ec1 = {}
+                  , asio::ip::tcp::endpoint const& ep= {}
+                  , system::error_code const& ec2 = {})
    {
       BOOST_ASIO_CORO_REENTER (coro)
       {
@@ -105,6 +107,8 @@ struct connect_op {
             asio::experimental::wait_for_one(),
             std::move(self));
 
+         runner->logger_.on_connect(ec1, ep);
+
          if (is_cancelled(self)) {
             self.complete(asio::error::operation_aborted);
             return;
@@ -160,10 +164,21 @@ struct runner_op {
    }
 };
 
-template <class Executor>
+template <class Executor, class Logger>
 class runner {
 public:
-   runner(Executor ex, address addr): resv_{ex}, timer_{ex}, addr_{addr} {}
+   using timer_type =
+      asio::basic_waitable_timer<
+         std::chrono::steady_clock,
+         asio::wait_traits<std::chrono::steady_clock>,
+         Executor>;
+
+   runner(Executor ex, address addr, Logger l = Logger{})
+   : resv_{ex}
+   , timer_{ex}
+   , addr_{addr}
+   , logger_{l}
+   {}
 
    template <class CompletionToken>
    auto async_resolve(CompletionToken&& token)
@@ -197,14 +212,14 @@ public:
          >(runner_op<runner, Connection>{this, &conn, resolve_timeout, connect_timeout}, token, resv_);
    }
 
+   void cancel()
+   {
+      resv_.cancel();
+      timer_.cancel();
+   }
+
 private:
    using resolver_type = asio::ip::basic_resolver<asio::ip::tcp, Executor>;
-   using timer_type =
-      asio::basic_waitable_timer<
-         std::chrono::steady_clock,
-         asio::wait_traits<std::chrono::steady_clock>,
-         Executor>;
-
 
    template <class, class> friend struct runner_op;
    template <class, class> friend struct connect_op;
@@ -214,6 +229,7 @@ private:
    timer_type timer_;
    address addr_;
    asio::ip::tcp::resolver::results_type endpoints_;
+   Logger logger_;
 };
 
 } // boost::redis::detail
diff --git a/include/boost/redis/logger.hpp b/include/boost/redis/logger.hpp
new file mode 100644
index 00000000..be52bec9
--- /dev/null
+++ b/include/boost/redis/logger.hpp
@@ -0,0 +1,45 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef BOOST_REDIS_LOGGER_HPP
+#define BOOST_REDIS_LOGGER_HPP
+
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/system/error_code.hpp>
+#include <iostream>
+
+namespace boost::redis {
+
+// TODO: Move to ipp file.
+// TODO: Implement filter.
+class logger {
+public:
+   void on_resolve(system::error_code const& ec, asio::ip::tcp::resolver::results_type const& res)
+   {
+      // TODO: Print the endpoints
+      std::clog << "on_resolve: " << ec.message() << std::endl;
+   }
+
+   void on_connect(system::error_code const& ec, asio::ip::tcp::endpoint const& ep)
+   {
+      // TODO: Print the endpoint
+      std::clog << "on_connect: " << ec.message() << std::endl;
+   }
+
+   void on_connection_lost()
+   {
+      std::clog << "on_connection_lost: " << std::endl;
+   }
+
+   void on_hello(system::error_code const& ec)
+   {
+      std::clog << "on_hello: " << ec.message() << std::endl;
+   }
+};
+
+} // boost::redis
+
+#endif // BOOST_REDIS_LOGGER_HPP
diff --git a/include/boost/redis/run.hpp b/include/boost/redis/run.hpp
index 3b081f6f..5da3dabb 100644
--- a/include/boost/redis/run.hpp
+++ b/include/boost/redis/run.hpp
@@ -7,16 +7,17 @@
 #ifndef BOOST_REDIS_RUN_HPP
 #define BOOST_REDIS_RUN_HPP
 
-// Has to included before promise.hpp to build on msvc.
 #include <boost/redis/detail/runner.hpp>
 #include <boost/redis/connection.hpp>
 #include <boost/redis/address.hpp>
+#include <boost/redis/logger.hpp>
 #include <boost/asio/compose.hpp>
 #include <boost/asio/consign.hpp>
 #include <memory>
 #include <chrono>
 
-namespace boost::redis {
+namespace boost::redis
+{
 
 /** @brief Call async_run on the connection.
  *  @ingroup high-level-api
@@ -35,6 +36,7 @@ namespace boost::redis {
  */
 template <
    class Socket,
+   class Logger = logger,
    class CompletionToken = asio::default_completion_token_t<typename Socket::executor_type>
 >
 auto
@@ -43,11 +45,12 @@ async_run(
    address addr = address{"127.0.0.1", "6379"},
    std::chrono::steady_clock::duration resolve_timeout = std::chrono::seconds{10},
    std::chrono::steady_clock::duration connect_timeout = std::chrono::seconds{10},
+   Logger l = Logger{},
    CompletionToken token = CompletionToken{})
 {
    using executor_type = typename Socket::executor_type;
-   using runner_type = detail::runner<executor_type>;
-   auto runner = std::make_shared<runner_type>(conn.get_executor(), addr);
+   using runner_type = detail::runner<executor_type, Logger>;
+   auto runner = std::make_shared<runner_type>(conn.get_executor(), addr, l);
 
    return
       runner->async_run(
diff --git a/tests/conn_check_health.cpp b/tests/conn_check_health.cpp
index cc410c0a..ffc770e8 100644
--- a/tests/conn_check_health.cpp
+++ b/tests/conn_check_health.cpp
@@ -5,6 +5,7 @@
  */
 
 #include <boost/redis/run.hpp>
+#include <boost/redis/logger.hpp>
 #include <boost/redis/check_health.hpp>
 #include <boost/system/errc.hpp>
 #define BOOST_TEST_MODULE check-health
@@ -22,6 +23,7 @@ using boost::redis::operation;
 using boost::redis::generic_response;
 using boost::redis::async_check_health;
 using boost::redis::async_run;
+using boost::redis::logger;
 using boost::redis::address;
 using namespace std::chrono_literals;
 
@@ -104,12 +106,12 @@ BOOST_AUTO_TEST_CASE(check_health)
    generic_response resp;
    push_callback{&conn, &conn2, &resp, &req2}(); // Starts reading pushes.
 
-   async_run(conn, address{}, 10s, 10s, [](auto ec){
+   async_run(conn, address{}, 10s, 10s, logger{}, [](auto ec){
       std::cout << "B" << std::endl;
       BOOST_TEST(!!ec);
    });
 
-   async_run(conn2, address{}, 10s, 10s, [](auto ec){
+   async_run(conn2, address{}, 10s, 10s, logger{}, [](auto ec){
       std::cout << "C" << std::endl;
       BOOST_TEST(!!ec);
    });
diff --git a/tests/conn_exec.cpp b/tests/conn_exec.cpp
index 050d0db3..a4dcfffc 100644
--- a/tests/conn_exec.cpp
+++ b/tests/conn_exec.cpp
@@ -6,6 +6,7 @@
 
 #include <boost/redis/run.hpp>
 #include <boost/redis/address.hpp>
+#include <boost/redis/logger.hpp>
 #include <boost/system/errc.hpp>
 #define BOOST_TEST_MODULE conn-exec
 #include <boost/test/included/unit_test.hpp>
@@ -26,6 +27,7 @@ using boost::redis::response;
 using boost::redis::ignore;
 using boost::redis::ignore_t;
 using boost::redis::async_run;
+using boost::redis::logger;
 using boost::redis::address;
 using namespace std::chrono_literals;
 
@@ -75,7 +77,7 @@ BOOST_AUTO_TEST_CASE(hello_priority)
       seen3 = true;
    });
 
-   async_run(conn, address{}, 10s, 10s, [](auto ec){
+   async_run(conn, address{}, 10s, 10s, logger{}, [](auto ec){
       BOOST_TEST(!ec);
    });
 
@@ -97,7 +99,7 @@ BOOST_AUTO_TEST_CASE(wrong_response_data_type)
    conn.async_exec(req, resp, [](auto ec, auto){
       BOOST_CHECK_EQUAL(ec, boost::redis::error::not_a_number);
    });
-   async_run(conn, address{}, 10s, 10s, [](auto ec){
+   async_run(conn, address{}, 10s, 10s, logger{}, [](auto ec){
       BOOST_CHECK_EQUAL(ec, boost::asio::error::basic_errors::operation_aborted);
    });
 
diff --git a/tests/conn_exec_cancel.cpp b/tests/conn_exec_cancel.cpp
index 7e2ecabe..3425b438 100644
--- a/tests/conn_exec_cancel.cpp
+++ b/tests/conn_exec_cancel.cpp
@@ -5,6 +5,7 @@
  */
 
 #include <boost/redis/run.hpp>
+#include <boost/redis/logger.hpp>
 #include <boost/system/errc.hpp>
 #define BOOST_TEST_MODULE conn-exec-cancel
 #include <boost/test/included/unit_test.hpp>
@@ -31,6 +32,7 @@ using boost::redis::generic_response;
 using boost::redis::ignore;
 using boost::redis::ignore_t;
 using boost::redis::async_run;
+using boost::redis::logger;
 using boost::redis::address;
 using connection = boost::asio::use_awaitable_t<>::as_default_on_t<boost::redis::connection>;
 using namespace std::chrono_literals;
@@ -42,7 +44,7 @@ auto async_ignore_explicit_cancel_of_req_written() -> net::awaitable<void>
    generic_response gresp;
    auto conn = std::make_shared<connection>(ex);
 
-   async_run(*conn, address{}, 10s, 10s, [conn](auto ec) {
+   async_run(*conn, address{}, 10s, 10s, logger{}, [conn](auto ec) {
       std::cout << "async_run: " << ec.message() << std::endl;
       BOOST_TEST(!ec);
    });
@@ -91,7 +93,7 @@ auto ignore_implicit_cancel_of_req_written() -> net::awaitable<void>
 
    // Calls async_run separately from the group of ops below to avoid
    // having it canceled when the timer fires.
-   async_run(*conn, address{}, 10s, 10s, [conn](auto ec) {
+   async_run(*conn, address{}, 10s, 10s, logger{}, [conn](auto ec) {
       BOOST_CHECK_EQUAL(ec, net::error::basic_errors::operation_aborted);
    });
 
@@ -156,7 +158,7 @@ BOOST_AUTO_TEST_CASE(test_cancel_of_req_written_on_run_canceled)
 
    conn.async_exec(req0, ignore, c0);
 
-   async_run(conn, address{}, 10s, 10s, [](auto ec){
+   async_run(conn, address{}, 10s, 10s, logger{}, [](auto ec){
       BOOST_CHECK_EQUAL(ec, net::error::basic_errors::operation_aborted);
    });
 
diff --git a/tests/conn_exec_error.cpp b/tests/conn_exec_error.cpp
index 75675201..93ae5bff 100644
--- a/tests/conn_exec_error.cpp
+++ b/tests/conn_exec_error.cpp
@@ -5,6 +5,7 @@
  */
 
 #include <boost/redis/run.hpp>
+#include <boost/redis/logger.hpp>
 #include <boost/system/errc.hpp>
 #define BOOST_TEST_MODULE conn-exec-error
 #include <boost/test/included/unit_test.hpp>
@@ -24,6 +25,7 @@ using boost::redis::ignore;
 using boost::redis::ignore_t;
 using boost::redis::error;
 using boost::redis::async_run;
+using boost::redis::logger;
 using boost::redis::address;
 using namespace std::chrono_literals;
 
@@ -42,7 +44,7 @@ BOOST_AUTO_TEST_CASE(no_ignore_error)
       BOOST_CHECK_EQUAL(ec, error::resp3_simple_error);
       conn.cancel(redis::operation::run);
    });
-   async_run(conn, address{}, 10s, 10s, [](auto ec){
+   async_run(conn, address{}, 10s, 10s, logger{}, [](auto ec){
       BOOST_CHECK_EQUAL(ec, boost::asio::error::basic_errors::operation_aborted);
    });
 
@@ -81,7 +83,7 @@ BOOST_AUTO_TEST_CASE(has_diagnostic)
 
       conn.cancel(redis::operation::run);
    });
-   async_run(conn, address{}, 10s, 10s, [](auto ec){
+   async_run(conn, address{}, 10s, 10s, logger{}, [](auto ec){
       BOOST_CHECK_EQUAL(ec, boost::asio::error::basic_errors::operation_aborted);
    });
 
@@ -130,7 +132,7 @@ BOOST_AUTO_TEST_CASE(resp3_error_in_cmd_pipeline)
    };
 
    conn.async_exec(req1, resp1, c1);
-   async_run(conn, address{}, 10s, 10s, [](auto ec){
+   async_run(conn, address{}, 10s, 10s, logger{}, [](auto ec){
       BOOST_CHECK_EQUAL(ec, boost::asio::error::basic_errors::operation_aborted);
    });
 
@@ -193,7 +195,7 @@ BOOST_AUTO_TEST_CASE(error_in_transaction)
 
       conn.cancel(redis::operation::run);
    });
-   async_run(conn, address{}, 10s, 10s, [](auto ec){
+   async_run(conn, address{}, 10s, 10s, logger{}, [](auto ec){
       BOOST_CHECK_EQUAL(ec, boost::asio::error::basic_errors::operation_aborted);
    });
 
@@ -243,7 +245,7 @@ BOOST_AUTO_TEST_CASE(subscriber_wrong_syntax)
    };
 
    conn.async_receive(gresp, c3);
-   async_run(conn, address{}, 10s, 10s, [](auto ec){
+   async_run(conn, address{}, 10s, 10s, logger{}, [](auto ec){
       std::cout << "async_run" << std::endl;
       BOOST_CHECK_EQUAL(ec, boost::asio::error::basic_errors::operation_aborted);
    });
diff --git a/tests/conn_exec_retry.cpp b/tests/conn_exec_retry.cpp
index 87a97139..bf70475b 100644
--- a/tests/conn_exec_retry.cpp
+++ b/tests/conn_exec_retry.cpp
@@ -25,6 +25,7 @@ using boost::redis::request;
 using boost::redis::response;
 using boost::redis::ignore;
 using boost::redis::async_run;
+using boost::redis::logger;
 using boost::redis::address;
 using namespace std::chrono_literals;
 
@@ -73,7 +74,7 @@ BOOST_AUTO_TEST_CASE(request_retry_false)
 
    conn.async_exec(req0, ignore, c0);
 
-   async_run(conn, address{}, 10s, 10s, [](auto ec){
+   async_run(conn, address{}, 10s, 10s, logger{}, [](auto ec){
       BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
    });
 
@@ -134,13 +135,13 @@ BOOST_AUTO_TEST_CASE(request_retry_true)
 
    conn.async_exec(req0, ignore, c0);
 
-   async_run(conn, address{}, 10s, 10s, [&](auto ec){
+   async_run(conn, address{}, 10s, 10s, logger{}, [&](auto ec){
       // The first cacellation.
       BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
       conn.reset_stream();
 
       // Reconnects and runs again to test req3.
-      async_run(conn, address{}, 10s, 10s, [](auto ec){
+      async_run(conn, address{}, 10s, 10s, logger{}, [](auto ec){
          std::cout << ec.message() << std::endl;
          BOOST_TEST(!ec);
       });
diff --git a/tests/conn_push.cpp b/tests/conn_push.cpp
index 089d8204..e6d07333 100644
--- a/tests/conn_push.cpp
+++ b/tests/conn_push.cpp
@@ -5,6 +5,7 @@
  */
 
 #include <boost/redis/run.hpp>
+#include <boost/redis/logger.hpp>
 #include <boost/system/errc.hpp>
 #include <boost/asio/detached.hpp>
 #include <boost/asio/co_spawn.hpp>
@@ -26,6 +27,7 @@ using boost::redis::response;
 using boost::redis::ignore;
 using boost::redis::ignore_t;
 using boost::redis::async_run;
+using boost::redis::logger;
 using boost::redis::address;
 using namespace std::chrono_literals;
 
@@ -65,7 +67,7 @@ BOOST_AUTO_TEST_CASE(receives_push_waiting_resps)
 
    conn.async_exec(req1, ignore, c1);
 
-   async_run(conn, address{}, 10s, 10s, [&](auto ec){
+   async_run(conn, address{}, 10s, 10s, logger{}, [&](auto ec){
       BOOST_TEST(!ec);
       conn.cancel(operation::receive);
    });
@@ -97,7 +99,7 @@ BOOST_AUTO_TEST_CASE(push_received1)
       BOOST_TEST(!ec);
    });
 
-   async_run(conn, address{}, 10s, 10s, [&](auto ec){
+   async_run(conn, address{}, 10s, 10s, logger{}, [&](auto ec){
       std::cout << "async_run: " << ec.message() << std::endl;
       conn.cancel(operation::receive);
    });
@@ -135,7 +137,7 @@ BOOST_AUTO_TEST_CASE(push_filtered_out)
       BOOST_TEST(!ec);
    });
 
-   async_run(conn, address{}, 10s, 10s, [&](auto ec){
+   async_run(conn, address{}, 10s, 10s, logger{}, [&](auto ec){
       BOOST_TEST(!ec);
    });
 
@@ -201,7 +203,7 @@ BOOST_AUTO_TEST_CASE(test_push_adapter)
       BOOST_CHECK_EQUAL(ec, net::experimental::error::channel_errors::channel_cancelled);
    });
 
-   async_run(conn, address{}, 10s, 10s, [](auto ec){
+   async_run(conn, address{}, 10s, 10s, logger{}, [](auto ec){
       BOOST_CHECK_EQUAL(ec, boost::system::errc::errc_t::operation_canceled);
    });
 
@@ -302,7 +304,7 @@ BOOST_AUTO_TEST_CASE(many_subscribers)
 
    conn.async_exec(req0, ignore,  c0);
 
-   async_run(conn, address{}, 10s, 10s, [&](auto ec){
+   async_run(conn, address{}, 10s, 10s, logger{}, [&](auto ec){
       BOOST_TEST(!ec);
       conn.cancel(operation::receive);
    });
diff --git a/tests/conn_quit.cpp b/tests/conn_quit.cpp
index 4a2f6ab5..77661544 100644
--- a/tests/conn_quit.cpp
+++ b/tests/conn_quit.cpp
@@ -5,6 +5,7 @@
  */
 
 #include <boost/redis/run.hpp>
+#include <boost/redis/logger.hpp>
 #include <boost/system/errc.hpp>
 #define BOOST_TEST_MODULE conn-quit
 #include <boost/test/included/unit_test.hpp>
@@ -21,6 +22,7 @@ using boost::redis::request;
 using boost::redis::response;
 using boost::redis::ignore;
 using boost::redis::async_run;
+using boost::redis::logger;
 using boost::redis::address;
 using namespace std::chrono_literals;
 
@@ -38,7 +40,7 @@ BOOST_AUTO_TEST_CASE(test_quit1)
       BOOST_TEST(!ec);
    });
 
-   async_run(conn, address{}, 10s, 10s, [&](auto ec){
+   async_run(conn, address{}, 10s, 10s, logger{}, [&](auto ec){
       BOOST_TEST(!ec);
    });
 
@@ -89,7 +91,7 @@ BOOST_AUTO_TEST_CASE(test_quit2)
 
    conn.async_exec(req1, ignore, c1);
 
-   async_run(conn, address{}, 10s, 10s, [&](auto ec){
+   async_run(conn, address{}, 10s, 10s, logger{}, [&](auto ec){
       BOOST_TEST(!ec);
    });
 
diff --git a/tests/conn_reconnect.cpp b/tests/conn_reconnect.cpp
index 0b866fda..fab680ad 100644
--- a/tests/conn_reconnect.cpp
+++ b/tests/conn_reconnect.cpp
@@ -5,6 +5,7 @@
  */
 
 #include <boost/redis/run.hpp>
+#include <boost/redis/logger.hpp>
 #include <boost/asio/detached.hpp>
 #define BOOST_TEST_MODULE conn-reconnect
 #include <boost/test/included/unit_test.hpp>
@@ -22,6 +23,7 @@ using boost::redis::request;
 using boost::redis::response;
 using boost::redis::ignore;
 using boost::redis::async_run;
+using boost::redis::logger;
 using boost::redis::address;
 using connection = boost::asio::use_awaitable_t<>::as_default_on_t<boost::redis::connection>;
 using namespace std::chrono_literals;
@@ -43,7 +45,7 @@ net::awaitable<void> test_reconnect_impl()
       boost::system::error_code ec1, ec2;
       co_await (
          conn.async_exec(req, ignore, net::redirect_error(net::use_awaitable, ec1)) &&
-         async_run(conn, addr, 10s, 10s, net::redirect_error(net::use_awaitable, ec2))
+         async_run(conn, addr, 10s, 10s, logger{}, net::redirect_error(net::use_awaitable, ec2))
       );
 
       BOOST_TEST(!ec1);
@@ -83,7 +85,7 @@ auto async_test_reconnect_timeout() -> net::awaitable<void>
    address addr;
    co_await (
       conn->async_exec(req1, ignore, redir(ec1)) ||
-      async_run(*conn, addr, 10s, 10s, redir(ec2)) ||
+      async_run(*conn, addr, 10s, 10s, logger{}, redir(ec2)) ||
       st.async_wait(redir(ec3))
    );
 
@@ -101,7 +103,7 @@ auto async_test_reconnect_timeout() -> net::awaitable<void>
    st.expires_after(std::chrono::seconds{1});
    co_await (
       conn->async_exec(req1, ignore, net::redirect_error(net::use_awaitable, ec1)) ||
-      async_run(*conn, addr, 10s, 10s, net::redirect_error(net::use_awaitable, ec2)) ||
+      async_run(*conn, addr, 10s, 10s, logger{}, net::redirect_error(net::use_awaitable, ec2)) ||
       st.async_wait(net::redirect_error(net::use_awaitable, ec3))
    );
    std::cout << "ccc" << std::endl;
diff --git a/tests/conn_run_cancel.cpp b/tests/conn_run_cancel.cpp
index 83bde896..3f0a8abd 100644
--- a/tests/conn_run_cancel.cpp
+++ b/tests/conn_run_cancel.cpp
@@ -5,6 +5,7 @@
  */
 
 #include <boost/redis/run.hpp>
+#include <boost/redis/logger.hpp>
 #include <boost/asio/detached.hpp>
 #include <boost/system/errc.hpp>
 #define BOOST_TEST_MODULE conn-run-cancel
@@ -27,6 +28,7 @@ using boost::redis::request;
 using boost::redis::response;
 using boost::redis::ignore;
 using boost::redis::async_run;
+using boost::redis::logger;
 using boost::redis::address;
 using namespace std::chrono_literals;
 
@@ -42,7 +44,7 @@ auto async_cancel_run_with_timer() -> net::awaitable<void>
 
    boost::system::error_code ec1, ec2;
    address addr;
-   co_await (async_run(conn, addr, 10s, 10s, redir(ec1)) || st.async_wait(redir(ec2)));
+   co_await (async_run(conn, addr, 10s, 10s, logger{}, redir(ec1)) || st.async_wait(redir(ec2)));
 
    BOOST_CHECK_EQUAL(ec1, boost::asio::error::basic_errors::operation_aborted);
    BOOST_TEST(!ec2);
@@ -67,7 +69,7 @@ async_check_cancellation_not_missed(int n, std::chrono::milliseconds ms) -> net:
       timer.expires_after(ms);
       boost::system::error_code ec1, ec2;
       address addr;
-      co_await (async_run(conn, addr, 10s, 10s, redir(ec1)) || timer.async_wait(redir(ec2)));
+      co_await (async_run(conn, addr, 10s, 10s, logger{}, redir(ec1)) || timer.async_wait(redir(ec2)));
       BOOST_CHECK_EQUAL(ec1, boost::asio::error::basic_errors::operation_aborted);
       std::cout << "Counter: " << i << std::endl;
    }
@@ -159,7 +161,7 @@ BOOST_AUTO_TEST_CASE(reset_before_run_completes)
       conn.reset_stream();
    });
    address addr;
-   async_run(conn, addr, 10s, 10s, [&](auto ec){
+   async_run(conn, addr, 10s, 10s, logger{}, [&](auto ec){
       BOOST_CHECK_EQUAL(ec, net::error::operation_aborted);
    });
 
diff --git a/tests/run.cpp b/tests/run.cpp
index 8fda0989..34c29d8b 100644
--- a/tests/run.cpp
+++ b/tests/run.cpp
@@ -5,6 +5,7 @@
  */
 
 #include <boost/redis/run.hpp>
+#include <boost/redis/logger.hpp>
 #define BOOST_TEST_MODULE run
 #include <boost/test/included/unit_test.hpp>
 #include <iostream>
@@ -14,6 +15,7 @@ namespace net = boost::asio;
 
 using connection = boost::redis::connection;
 using boost::redis::async_run;
+using boost::redis::logger;
 using boost::redis::address;
 using boost::system::error_code;
 using namespace std::chrono_literals;
@@ -30,7 +32,7 @@ BOOST_AUTO_TEST_CASE(resolve_bad_host)
    net::io_context ioc;
 
    connection conn{ioc};
-   async_run(conn, address{{"Atibaia"}, {"6379"}}, 1000s, 1000s, [](auto ec){
+   async_run(conn, address{{"Atibaia"}, {"6379"}}, 1000s, 1000s, logger{}, [](auto ec){
       BOOST_TEST(is_host_not_found(ec));
    });
 
@@ -42,7 +44,7 @@ BOOST_AUTO_TEST_CASE(resolve_with_timeout)
    net::io_context ioc;
 
    connection conn{ioc};
-   async_run(conn, address{{"Atibaia"}, {"6379"}}, 1ms, 1ms, [](auto ec){
+   async_run(conn, address{{"Atibaia"}, {"6379"}}, 1ms, 1ms, logger{}, [](auto ec){
       BOOST_CHECK_EQUAL(ec, boost::redis::error::resolve_timeout);
    });
 
@@ -54,7 +56,7 @@ BOOST_AUTO_TEST_CASE(connect_bad_port)
    net::io_context ioc;
 
    connection conn{ioc};
-   async_run(conn, address{{"127.0.0.1"}, {"1"}}, 1000s, 10s, [](auto ec){
+   async_run(conn, address{{"127.0.0.1"}, {"1"}}, 1000s, 10s, logger{}, [](auto ec){
       BOOST_CHECK_EQUAL(ec, net::error::basic_errors::connection_refused);
    });
 
@@ -66,7 +68,7 @@ BOOST_AUTO_TEST_CASE(connect_with_timeout)
    net::io_context ioc;
 
    connection conn{ioc};
-   async_run(conn, address{{"example.com"}, {"1"}}, 10s, 1ms, [](auto ec){
+   async_run(conn, address{{"example.com"}, {"1"}}, 10s, 1ms, logger{}, [](auto ec){
       BOOST_CHECK_EQUAL(ec, boost::redis::error::connect_timeout);
    });