couchbase 3.5.7 → 3.6.0

data/ext/couchbase/core/io/http_session_manager.hxx

@@ -19,6 +19,7 @@
 
 #include <couchbase/build_config.hxx>
 
+#include "core/app_telemetry_meter.hxx"
 #include "core/config_listener.hxx"
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
 #include "core/columnar/bootstrap_notification_subscriber.hxx"
@@ -74,6 +75,11 @@ public:
     meter_ = std::move(meter);
   }
 
+  void set_app_telemetry_meter(std::shared_ptr<core::app_telemetry_meter> app_telemetry_meter)
+  {
+    app_telemetry_meter_ = std::move(app_telemetry_meter);
+  }
+
   auto configuration_capabilities() const -> configuration_capabilities
   {
     std::scoped_lock config_lock(config_mutex_);
@@ -203,7 +209,7 @@ public:
         std::uint16_t port = node.port_or(options_.network, type, options_.enable_tls, 0);
         if (port != 0) {
           const auto& hostname = node.hostname_for(options_.network);
-          auto session = create_session(type, credentials, hostname, port);
+          auto session = create_session(type, credentials, hostname, port, node.node_uuid);
           if (session->is_connected()) {
             std::scoped_lock lock(sessions_mutex_);
             busy_sessions_[type].push_back(session);
@@ -217,11 +223,17 @@ public:
             request,
             tracer_,
             meter_,
+            app_telemetry_meter_,
             options_.default_timeout_for(request.type),
             dispatch_timeout_);
 #else
           auto cmd = std::make_shared<operations::http_command<operations::http_noop_request>>(
-            ctx_, request, tracer_, meter_, options_.default_timeout_for(request.type));
+            ctx_,
+            request,
+            tracer_,
+            meter_,
+            app_telemetry_meter_,
+            options_.default_timeout_for(request.type));
 #endif
 
           cmd->start([start = std::chrono::steady_clock::now(),
@@ -283,6 +295,7 @@ public:
                                         error });
             self->check_in(type, cmd->session_);
           });
+
           cmd->set_command_session(session);
           if (!session->is_connected()) {
             connect_then_send(session, cmd, {}, true);
@@ -300,10 +313,13 @@ public:
                  const std::string& undesired_node = {})
     -> std::pair<std::error_code, std::shared_ptr<http_session>>
   {
+    std::string node_uuid{};
+
     if (preferred_node.empty() && !undesired_node.empty()) {
-      auto [hostname, port] = pick_random_node(type, undesired_node);
+      auto [hostname, port, uuid] = pick_random_node(type, undesired_node);
       if (port != 0) {
         preferred_node = fmt::format("{}:{}", hostname, port);
+        node_uuid = uuid;
       }
     }
 
@@ -343,7 +359,7 @@ public:
             break;
           }
         } else {
-          session = create_session(type, credentials, hostname, port);
+          session = create_session(type, credentials, hostname, port, node_uuid);
           break;
         }
       }
@@ -355,12 +371,12 @@ public:
       session.reset();
     }
     if (!session) {
-      auto [hostname, port] =
+      auto [hostname, port, uuid] =
         preferred_node.empty() ? next_node(type) : lookup_node(type, preferred_node);
       if (port == 0) {
         return { errc::common::service_not_available, nullptr };
       }
-      session = create_session(type, credentials, hostname, port);
+      session = create_session(type, credentials, hostname, port, uuid);
     }
     if (session->is_connected()) {
       busy_sessions_[type].push_back(session);
@@ -472,13 +488,19 @@ public:
       request,
       tracer_,
       meter_,
+      app_telemetry_meter_,
       options_.default_timeout_for(request.type),
       dispatch_timeout_);
     cmd->start([self = shared_from_this(), cmd, handler = std::forward<Handler>(handler)](
                  error_union err, io::http_response&& msg) mutable {
 #else
     auto cmd = std::make_shared<operations::http_command<Request>>(
-      ctx_, request, tracer_, meter_, options_.default_timeout_for(request.type));
+      ctx_,
+      request,
+      tracer_,
+      meter_,
+      app_telemetry_meter_,
+      options_.default_timeout_for(request.type));
     cmd->start([self = shared_from_this(), cmd, handler = std::forward<Handler>(handler)](
                  std::error_code ec, io::http_response&& msg) mutable {
 #endif
@@ -571,15 +593,15 @@ public:
 
         // stop this session and create a new one w/ new hostname + port
         session->stop();
-        auto [hostname, port] = preferred_node.empty()
-                                  ? self->next_node(session->type())
-                                  : self->lookup_node(session->type(), preferred_node);
+        auto [hostname, port, node_uuid] = preferred_node.empty()
+                                             ? self->next_node(session->type())
+                                             : self->lookup_node(session->type(), preferred_node);
         if (port == 0) {
           cb(errc::common::service_not_available, {});
           return;
         }
         auto new_session =
-          self->create_session(session->type(), session->credentials(), hostname, port);
+          self->create_session(session->type(), session->credentials(), hostname, port, node_uuid);
         if (new_session->is_connected()) {
           {
             const std::scoped_lock inner_lock(self->sessions_mutex_);
@@ -679,15 +701,15 @@ private:
         }
         // stop this session and create a new one w/ new hostname + port
         session->stop();
-        auto [hostname, port] = preferred_node.empty()
-                                  ? self->next_node(session->type())
-                                  : self->lookup_node(session->type(), preferred_node);
+        auto [hostname, port, node_uuid] = preferred_node.empty()
+                                             ? self->next_node(session->type())
+                                             : self->lookup_node(session->type(), preferred_node);
         if (port == 0) {
           cmd->invoke_handler(errc::common::service_not_available, {});
           return;
         }
         auto new_session =
-          self->create_session(session->type(), session->credentials(), hostname, port);
+          self->create_session(session->type(), session->credentials(), hostname, port, node_uuid);
         cmd->set_command_session(new_session);
         if (new_session->is_connected()) {
           std::scoped_lock inner_lock(self->sessions_mutex_);
@@ -707,13 +729,15 @@ private:
   auto create_session(service_type type,
                       const couchbase::core::cluster_credentials& credentials,
                       const std::string& hostname,
-                      std::uint16_t port) -> std::shared_ptr<http_session>
+                      std::uint16_t port,
+                      const std::string& node_uuid) -> std::shared_ptr<http_session>
   {
     std::shared_ptr<http_session> session;
     if (options_.enable_tls) {
       session = std::make_shared<http_session>(
         type,
         client_id_,
+        node_uuid,
         ctx_,
         tls_,
         credentials,
@@ -724,6 +748,7 @@ private:
       session = std::make_shared<http_session>(
         type,
         client_id_,
+        node_uuid,
         ctx_,
         credentials,
         hostname,
@@ -763,6 +788,7 @@ private:
       request,
       tracer_,
       meter_,
+      app_telemetry_meter_,
       options_.default_timeout_for(request.type),
       dispatch_timeout_);
     cmd->start([self = shared_from_this(), cmd, handler = std::forward<Handler>(handler)](
@@ -852,7 +878,7 @@ private:
   }
 #endif
 
-  auto next_node(service_type type) -> std::pair<std::string, std::uint16_t>
+  auto next_node(service_type type) -> std::tuple<std::string, std::uint16_t, std::string>
   {
     std::scoped_lock lock(config_mutex_);
     auto candidates = config_.nodes.size();
@@ -863,10 +889,18 @@ private:
       next_index_ = (next_index_ + 1) % config_.nodes.size();
       std::uint16_t port = node.port_or(options_.network, type, options_.enable_tls, 0);
       if (port != 0) {
-        return { node.hostname_for(options_.network), port };
+        return {
+          node.hostname_for(options_.network),
+          port,
+          node.node_uuid,
+        };
       }
     }
-    return { "", static_cast<std::uint16_t>(0U) };
+    return {
+      "",
+      static_cast<std::uint16_t>(0U),
+      "",
+    };
   }
 
   auto split_host_port(const std::string& address) -> std::pair<std::string, std::uint16_t>
@@ -880,24 +914,30 @@ private:
     return { hostname, port };
   }
 
-  auto lookup_node(service_type type,
-                   const std::string& preferred_node) -> std::pair<std::string, std::uint16_t>
+  auto lookup_node(service_type type, const std::string& preferred_node)
+    -> std::tuple<std::string, std::uint16_t, std::string>
   {
     std::scoped_lock lock(config_mutex_);
     auto [hostname, port] = split_host_port(preferred_node);
-    if (std::none_of(config_.nodes.begin(),
-                     config_.nodes.end(),
-                     [this, type, &h = hostname, &p = port](const auto& node) {
-                       return node.hostname_for(options_.network) == h &&
-                              node.port_or(options_.network, type, options_.enable_tls, 0) == p;
-                     })) {
-      return { "", static_cast<std::uint16_t>(0U) };
+    for (const auto& node : config_.nodes) {
+      if (node.hostname_for(options_.network) == hostname &&
+          node.port_or(options_.network, type, options_.enable_tls, 0) == port) {
+        return {
+          hostname,
+          port,
+          node.node_uuid,
+        };
+      }
     }
-    return { hostname, port };
+    return {
+      "",
+      static_cast<std::uint16_t>(0U),
+      "",
+    };
   }
 
-  auto pick_random_node(service_type type,
-                        const std::string& undesired_node) -> std::pair<std::string, std::uint16_t>
+  auto pick_random_node(service_type type, const std::string& undesired_node)
+    -> std::tuple<std::string, std::uint16_t, std::string>
   {
     std::vector<topology::configuration::node> candidate_nodes{};
     {
@@ -913,7 +953,11 @@ private:
 
     if (candidate_nodes.empty()) {
       // Could not find any other nodes
-      return { "", static_cast<std::uint16_t>(0U) };
+      return {
+        "",
+        static_cast<std::uint16_t>(0U),
+        "",
+      };
     }
 
     std::vector<topology::configuration::node> selected{};
@@ -922,8 +966,12 @@ private:
                 std::back_inserter(selected),
                 1,
                 std::mt19937{ std::random_device{}() });
-    return { selected.at(0).hostname_for(options_.network),
-             selected.at(0).port_or(options_.network, type, options_.enable_tls, 0) };
+    const auto& first_selected = selected.at(0);
+    return {
+      first_selected.hostname_for(options_.network),
+      first_selected.port_or(options_.network, type, options_.enable_tls, 0),
+      first_selected.node_uuid,
+    };
   }
 
   std::string client_id_;
@@ -931,6 +979,7 @@ private:
   asio::ssl::context& tls_;
   std::shared_ptr<tracing::tracer_wrapper> tracer_{ nullptr };
   std::shared_ptr<metrics::meter_wrapper> meter_{ nullptr };
+  std::shared_ptr<core::app_telemetry_meter> app_telemetry_meter_{ nullptr };
   cluster_options options_{};
 
   topology::configuration config_{};

data/ext/couchbase/core/io/mcbp_command.hxx

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include "core/app_telemetry_meter.hxx"
 #include "core/document_id_fmt.hxx"
 #include "core/error_context/key_value_error_map_info.hxx"
 #include "core/metrics/meter_wrapper.hxx"
@@ -146,7 +147,12 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
       span_ = nullptr;
     }
     if (handler) {
+      const auto& node_uuid = session_ ? session_->node_uuid() : "";
+      auto telemetry_recorder =
+        manager_->app_telemetry_meter()->value_recorder(node_uuid, manager_->name());
+      telemetry_recorder->update_counter(app_telemetry_counter::kv_r_total);
       if (ec == errc::common::unambiguous_timeout || ec == errc::common::ambiguous_timeout) {
+        telemetry_recorder->update_counter(app_telemetry_counter::kv_r_timedout);
         auto time_left = deadline.expiry() - std::chrono::steady_clock::now();
         CB_LOG_TRACE(R"([{}] timeout operation id="{}", {}, key="{}", partition={}, time_left={})",
                      session_ ? session_->log_prefix() : manager_->log_prefix(),
@@ -155,6 +161,8 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
                      request.id,
                      request.partition,
                      time_left);
+      } else if (ec == errc::common::request_canceled) {
+        telemetry_recorder->update_counter(app_telemetry_counter::kv_r_canceled);
       }
       handler(ec, std::move(msg));
     }
@@ -267,6 +275,35 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
         retry_reason reason,
         io::mcbp_message&& msg,
         std::optional<key_value_error_map_info> /* error_info */) mutable {
+        {
+          auto latency = std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::steady_clock::now() - start);
+          auto category = app_telemetry_latency::kv_retrieval;
+          switch (encoded_request_type::body_type::opcode) {
+            case protocol::client_opcode::upsert:
+            case protocol::client_opcode::insert:
+            case protocol::client_opcode::replace:
+            case protocol::client_opcode::remove:
+            case protocol::client_opcode::increment:
+            case protocol::client_opcode::decrement:
+            case protocol::client_opcode::append:
+            case protocol::client_opcode::prepend:
+              category = app_telemetry_latency::kv_mutation_nondurable;
+              if constexpr (io::mcbp_traits::supports_durability_v<Request>) {
+                if (self->request.durability_level != durability_level::none) {
+                  category = app_telemetry_latency::kv_mutation_durable;
+                }
+              }
+              break;
+            default:
+              break;
+          }
+
+          auto telemetry_recorder = self->manager_->app_telemetry_meter()->value_recorder(
+            self->session_->node_uuid(), self->manager_->name());
+          telemetry_recorder->record_latency(category, latency);
+        }
+
         metrics::metric_attributes attrs{
           service_type::key_value,
           self->request.observability_identifier,
@@ -279,16 +316,18 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
 
         self->retry_backoff.cancel();
         if (ec == asio::error::operation_aborted) {
-          if (self->span_->uses_tags())
+          if (self->span_->uses_tags()) {
             self->span_->add_tag(tracing::attributes::orphan, "aborted");
+          }
           return self->invoke_handler(make_error_code(self->request.retries.idempotent()
                                                         ? errc::common::unambiguous_timeout
                                                         : errc::common::ambiguous_timeout));
         }
         if (ec == errc::common::request_canceled) {
           if (!self->request.retries.idempotent() && !allows_non_idempotent_retry(reason)) {
-            if (self->span_->uses_tags())
+            if (self->span_->uses_tags()) {
               self->span_->add_tag(tracing::attributes::orphan, "canceled");
+            }
             return self->invoke_handler(ec);
           }
           return io::retry_orchestrator::maybe_retry(self->manager_, self, reason, ec);

data/ext/couchbase/core/io/mcbp_session.cxx

@@ -414,10 +414,11 @@ class mcbp_session_impl
               const protocol::client_response<protocol::sasl_list_mechs_response_body> resp(
                 std::move(msg));
               if (resp.status() != key_value_status_code::success) {
-                auto error_msg =
-                  fmt::format("unexpected message status during bootstrap: {} (opaque={})",
-                              resp.error_message(),
-                              resp.opaque());
+                auto error_msg = fmt::format(
+                  "unexpected message status during bootstrap: {} (opaque={}, context={})",
+                  resp.error_message(),
+                  resp.opaque(),
+                  resp.error_info() ? resp.error_info()->context() : "");
                 last_bootstrap_error_ = { errc::common::authentication_failure,
                                           std::move(error_msg),
                                           session_->bootstrap_hostname(),
@@ -443,8 +444,11 @@ class mcbp_session_impl
                   req.body().sasl_data(sasl_payload);
                   session_->write_and_flush(req.data());
                 } else {
-                  auto error_msg = fmt::format(
-                    "unable to authenticate: (sasl_code={}, opaque={})", sasl_code, resp.opaque());
+                  auto error_msg =
+                    fmt::format("unable to authenticate: (sasl_code={}, opaque={}, context={})",
+                                sasl_code,
+                                resp.opaque(),
+                                resp.error_info() ? resp.error_info()->context() : "");
                   last_bootstrap_error_ = { errc::common::authentication_failure,
                                             std::move(error_msg),
                                             session_->bootstrap_hostname(),
@@ -453,11 +457,12 @@ class mcbp_session_impl
                   return complete(errc::common::authentication_failure);
                 }
               } else {
-                auto error_msg =
-                  fmt::format("{} unexpected message status during bootstrap: {} (opaque={})",
-                              session_->log_prefix_,
-                              resp.error_message(),
-                              resp.opaque());
+                auto error_msg = fmt::format(
+                  "{} unexpected message status during bootstrap: {} (opaque={}, context={})",
+                  session_->log_prefix_,
+                  resp.error_message(),
+                  resp.opaque(),
+                  resp.error_info() ? resp.error_info()->context() : "");
                 last_bootstrap_error_ = { errc::common::authentication_failure,
                                           std::move(error_msg),
                                           session_->bootstrap_hostname(),
@@ -473,10 +478,11 @@ class mcbp_session_impl
                 return auth_success();
               }
               auto error_msg =
-                fmt::format("unable to authenticate (opcode={}, status={}, opaque={})",
+                fmt::format("unable to authenticate (opcode={}, status={}, opaque={}, context={})",
                             opcode,
                             resp.status(),
-                            resp.opaque());
+                            resp.opaque(),
+                            resp.error_info() ? resp.error_info()->context() : "");
               last_bootstrap_error_ = { errc::common::authentication_failure,
                                         std::move(error_msg),
                                         session_->bootstrap_hostname(),
@@ -858,19 +864,21 @@ class mcbp_session_impl
 public:
   mcbp_session_impl() = delete;
   mcbp_session_impl(std::string_view client_id,
+                    std::string_view node_uuid,
                     asio::io_context& ctx,
                     couchbase::core::origin origin,
                     std::shared_ptr<impl::bootstrap_state_listener> state_listener,
                     std::optional<std::string> bucket_name = {},
                     std::vector<protocol::hello_feature> known_features = {})
     : client_id_(client_id)
+    , node_uuid_(node_uuid)
     , ctx_(ctx)
     , resolver_(ctx_)
     , stream_(std::make_unique<plain_stream_impl>(ctx_))
     , bootstrap_deadline_(ctx_)
     , connection_deadline_(ctx_)
     , retry_backoff_(ctx_)
-    , ping_deadline_(ctx_)
+    , ping_timeout_(ctx_)
     , origin_{ std::move(origin) }
     , bucket_name_{ std::move(bucket_name) }
     , supported_features_{ std::move(known_features) }
@@ -883,6 +891,7 @@ public:
   }
 
   mcbp_session_impl(std::string_view client_id,
+                    std::string_view node_uuid,
                     asio::io_context& ctx,
                     asio::ssl::context& tls,
                     couchbase::core::origin origin,
@@ -890,13 +899,14 @@ public:
                     std::optional<std::string> bucket_name = {},
                     std::vector<protocol::hello_feature> known_features = {})
     : client_id_(client_id)
+    , node_uuid_(node_uuid)
     , ctx_(ctx)
     , resolver_(ctx_)
     , stream_(std::make_unique<tls_stream_impl>(ctx_, tls))
     , bootstrap_deadline_(ctx_)
     , connection_deadline_(ctx_)
     , retry_backoff_(ctx_)
-    , ping_deadline_(ctx_)
+    , ping_timeout_(ctx_)
     , origin_(std::move(origin))
     , bucket_name_(std::move(bucket_name))
     , supported_features_(std::move(known_features))
@@ -998,8 +1008,8 @@ public:
           error,
         });
       });
-    ping_deadline_.expires_after(timeout.value_or(origin_.options().key_value_timeout));
-    ping_deadline_.async_wait(
+    ping_timeout_.expires_after(timeout.value_or(origin_.options().key_value_timeout));
+    ping_timeout_.async_wait(
       [self = this->shared_from_this(), opaque = req.opaque()](std::error_code ec) {
         if (ec == asio::error::operation_aborted) {
           return;
@@ -1154,6 +1164,11 @@ public:
     return id_;
   }
 
+  [[nodiscard]] auto node_uuid() const -> const std::string&
+  {
+    return node_uuid_;
+  }
+
   [[nodiscard]] auto is_stopped() const -> bool
   {
     return stopped_;
@@ -1194,7 +1209,7 @@ public:
     bootstrap_deadline_.cancel();
     connection_deadline_.cancel();
     retry_backoff_.cancel();
-    ping_deadline_.cancel();
+    ping_timeout_.cancel();
     resolver_.cancel();
     stream_->close([](std::error_code) {
     });
@@ -1711,6 +1726,13 @@ private:
     if (ec) {
       return stop(retry_reason::node_not_available);
     }
+    if (node_uuid_.empty() && config_.has_value()) {
+      for (const auto& node : config_.value().nodes) {
+        if (node.this_node) {
+          node_uuid_ = node.node_uuid;
+        }
+      }
+    }
     state_ = diag::endpoint_state::connected;
     const std::scoped_lock lock(pending_buffer_mutex_);
     bootstrapped_ = true;
@@ -2020,6 +2042,7 @@ private:
   }
 
   const std::string client_id_;
+  std::string node_uuid_;
   const std::string id_{ uuid::to_string(uuid::random()) };
   asio::io_context& ctx_;
   asio::ip::tcp::resolver resolver_;
@@ -2027,7 +2050,7 @@ private:
   asio::steady_timer bootstrap_deadline_;
   asio::steady_timer connection_deadline_;
   asio::steady_timer retry_backoff_;
-  asio::steady_timer ping_deadline_;
+  asio::steady_timer ping_timeout_;
   couchbase::core::origin origin_;
   std::optional<std::string> bucket_name_;
   mcbp_parser parser_;
@@ -2092,12 +2115,14 @@ private:
 };
 
 mcbp_session::mcbp_session(const std::string& client_id,
+                           const std::string& node_uuid,
                            asio::io_context& ctx,
                            core::origin origin,
                            std::shared_ptr<impl::bootstrap_state_listener> state_listener,
                            std::optional<std::string> bucket_name,
                            std::vector<protocol::hello_feature> known_features)
   : impl_{ std::make_shared<mcbp_session_impl>(client_id,
+                                               node_uuid,
                                                ctx,
                                                std::move(origin),
                                                std::move(state_listener),
@@ -2107,6 +2132,7 @@ mcbp_session::mcbp_session(const std::string& client_id,
 }
 
 mcbp_session::mcbp_session(const std::string& client_id,
+                           const std::string& node_uuid,
                            asio::io_context& ctx,
                            asio::ssl::context& tls,
                            core::origin origin,
@@ -2114,6 +2140,7 @@ mcbp_session::mcbp_session(const std::string& client_id,
                            std::optional<std::string> bucket_name,
                            std::vector<protocol::hello_feature> known_features)
   : impl_{ std::make_shared<mcbp_session_impl>(client_id,
+                                               node_uuid,
                                                ctx,
                                                tls,
                                                std::move(origin),
@@ -2177,6 +2204,12 @@ mcbp_session::id() const -> const std::string&
   return impl_->id();
 }
 
+auto
+mcbp_session::node_uuid() const -> const std::string&
+{
+  return impl_->node_uuid();
+}
+
 auto
 mcbp_session::bootstrap_address() const -> const std::string&
 {

data/ext/couchbase/core/io/mcbp_session.hxx

@@ -90,6 +90,7 @@ public:
   auto operator=(mcbp_session&& other) -> mcbp_session& = default;
 
   mcbp_session(const std::string& client_id,
+               const std::string& node_uuid,
                asio::io_context& ctx,
                couchbase::core::origin origin,
                std::shared_ptr<impl::bootstrap_state_listener> state_listener,
@@ -97,6 +98,7 @@ public:
                std::vector<protocol::hello_feature> known_features = {});
 
   mcbp_session(const std::string& client_id,
+               const std::string& node_uuid,
                asio::io_context& ctx,
                asio::ssl::context& tls,
                couchbase::core::origin origin,
@@ -115,6 +117,7 @@ public:
   [[nodiscard]] auto supports_feature(protocol::hello_feature feature) -> bool;
   [[nodiscard]] auto supported_features() const -> std::vector<protocol::hello_feature>;
   [[nodiscard]] auto id() const -> const std::string&;
+  [[nodiscard]] auto node_uuid() const -> const std::string&;
   [[nodiscard]] auto remote_address() const -> std::string;
   [[nodiscard]] auto local_address() const -> std::string;
   [[nodiscard]] auto bootstrap_address() const -> const std::string&;

data/ext/couchbase/core/logger/logger.cxx

@@ -59,6 +59,10 @@ std::shared_ptr<spdlog::logger> file_logger{};
 std::mutex file_logger_mutex;
 std::atomic_int file_logger_version{ 0 };
 
+std::shared_ptr<couchbase::core::logger::log_callback> log_callback{};
+std::mutex log_callback_mutex;
+std::atomic_int log_callback_version{ 0 };
+
 auto
 get_file_logger() -> std::shared_ptr<spdlog::logger>
 {
@@ -72,6 +76,27 @@ get_file_logger() -> std::shared_ptr<spdlog::logger>
   return logger;
 }
 
+auto
+get_custom_callback() -> std::shared_ptr<couchbase::core::logger::log_callback>
+{
+  thread_local std::shared_ptr<couchbase::core::logger::log_callback> callback{ nullptr };
+  thread_local int version{ -1 };
+  if (version != log_callback_version) {
+    const std::scoped_lock lock(log_callback_mutex);
+    callback = log_callback;
+    version = log_callback_version;
+  }
+  return callback;
+}
+
+void
+update_callback_logger(const std::shared_ptr<couchbase::core::logger::log_callback>& new_callback)
+{
+  const std::scoped_lock lock(log_callback_mutex);
+  log_callback = new_callback;
+  ++log_callback_version;
+}
+
 void
 update_file_logger(const std::shared_ptr<spdlog::logger>& new_logger)
 {
@@ -181,6 +206,14 @@ log(const char* file, int line, const char* function, level lvl, std::string_vie
       spdlog::source_loc{ file, line, function }, translate_level(lvl), msg);
   }
 }
+
+void
+log_custom_logger(const char* file, int line, const char* function, level lvl, std::string_view msg)
+{
+  if (auto callback = get_custom_callback()) {
+    (*callback)(msg, lvl, { file, function, line });
+  }
+}
 } // namespace detail
 
 void
@@ -396,6 +429,19 @@ create_console_logger()
   update_file_logger(new_logger);
 }
 
+void
+register_log_callback(log_callback callback)
+{
+  auto new_callback = std::make_shared<log_callback>(std::move(callback));
+  update_callback_logger(new_callback);
+}
+
+void
+unregister_log_callback()
+{
+  update_callback_logger(nullptr);
+}
+
 void
 register_spdlog_logger(const std::shared_ptr<spdlog::logger>& l)
 {