couchbase 3.8.2 → 3.9.0

data/ext/couchbase/core/cluster.hxx

@@ -20,6 +20,8 @@
 #include "deprecation_utils.hxx"
 #include "diagnostics.hxx"
 #include "error.hxx"
+#include "error_context/analytics.hxx"
+#include "error_context/query.hxx"
 #include "operations_fwd.hxx"
 #include "origin.hxx"
 #include "topology/configuration.hxx"
@@ -40,6 +42,9 @@ namespace couchbase::core
 class crud_component;
 class cluster_impl;
 class cluster_label_listener;
+class bucket;
+class query_stream;
+class analytics_stream;
 
 namespace tracing
 {
@@ -70,6 +75,7 @@ class cluster
 {
 public:
   explicit cluster(asio::io_context& ctx);
+  explicit cluster(std::shared_ptr<cluster_impl> impl);
 
   [[nodiscard]] auto io_context() const -> asio::io_context&;
 
@@ -77,9 +83,6 @@ public:
 
   void open(core::origin origin, utils::movable_function<void(std::error_code)>&& handler) const;
 
-  void open_in_background(const couchbase::core::origin& origin,
-                          utils::movable_function<void(std::error_code)>&& handler) const;
-
   void close(utils::movable_function<void()>&& handler) const;
 
   void open_bucket(const std::string& bucket_name,
@@ -119,6 +122,23 @@ public:
   void execute(o::mutate_in_request request, mf<void(o::mutate_in_response)>&& handler) const;
   void execute(o::prepend_request request, mf<void(o::prepend_response)>&& handler) const;
   void execute(o::query_request request, mf<void(o::query_response)>&& handler) const;
+
+  /**
+   * Dispatches a N1QL query as a streaming request, resolving the handler with a query_stream
+   * handle once the response preamble (signature + upfront errors) has been parsed. Rows are then
+   * pulled lazily from the handle, so the full response body is never buffered.
+   */
+  void query_stream(o::query_request request,
+                    mf<void(query_stream, error_context::query)>&& handler) const;
+
+  /**
+   * Dispatches an analytics query as a streaming request, resolving the handler with an
+   * analytics_stream handle once the response preamble (signature + upfront errors) has been
+   * parsed. Rows are then pulled lazily from the handle, so the full response body is never
+   * buffered.
+   */
+  void analytics_query_stream(o::analytics_request request,
+                              mf<void(analytics_stream, error_context::analytics)>&& handler) const;
   void execute(o::remove_request request, mf<void(o::remove_response)>&& handler) const;
   void execute(o::replace_request request, mf<void(o::replace_response)>&& handler) const;
   void execute(o::search_request request, mf<void(o::search_response)>&& handler) const;
@@ -285,15 +305,15 @@ public:
   void execute(om::cluster_describe_request request,
                mf<void(om::cluster_describe_response)>&& handler) const;
 
-  void execute(impl::get_replica_request request,
-               mf<void(impl::get_replica_response)>&& handler) const;
+  void execute(operations::get_replica_request request,
+               mf<void(operations::get_replica_response)>&& handler) const;
   void execute(impl::lookup_in_replica_request request,
                mf<void(impl::lookup_in_replica_response)>&& handler) const;
   void execute(impl::observe_seqno_request request,
                mf<void(impl::observe_seqno_response)>&& handler) const;
 
   void execute(o::get_replica_request_with_cancellation request,
-               mf<void(impl::get_replica_response)>&& handler) const;
+               mf<void(operations::get_replica_response)>&& handler) const;
   void execute(o::get_request_with_cancellation request, mf<void(o::get_response)>&& handler) const;
   void execute(o::lookup_in_request_with_cancellation request,
                mf<void(o::lookup_in_response)>&& handler) const;
@@ -339,10 +359,21 @@ public:
 
   [[nodiscard]] auto to_string() const -> std::string;
 
-  [[nodiscard]] auto tracer() const -> const std::shared_ptr<tracing::tracer_wrapper>&;
-  [[nodiscard]] auto meter() const -> const std::shared_ptr<metrics::meter_wrapper>&;
+  [[nodiscard]] auto tracer() const -> std::shared_ptr<tracing::tracer_wrapper>;
+  [[nodiscard]] auto meter() const -> std::shared_ptr<metrics::meter_wrapper>;
   [[nodiscard]] auto cluster_label_listener() const
     -> const std::shared_ptr<cluster_label_listener>&;
+  [[nodiscard]] auto find_bucket_by_name(const std::string& name) const -> std::shared_ptr<bucket>;
+  [[nodiscard]] auto is_protostellar() const -> bool;
+  // couchbase2 only: whether the gRPC channel is READY, asking an idle channel to connect.
+  // cluster_closed once the cluster is closed, feature_not_available for any other cluster.
+  [[nodiscard]] auto protostellar_channel_ready() const -> std::pair<std::error_code, bool>;
+  // Calls `hook` on the io_context during close(), before close()'s handler, if `owner` is still
+  // alive then. Returns false, without registering, once the cluster is stopped. open() also stops
+  // it without calling hooks when the origin has no nodes, the build has no couchbase2 support, or
+  // the couchbase2 channel cannot be built.
+  [[nodiscard]] auto add_close_hook(std::weak_ptr<void> owner,
+                                    utils::movable_function<void()>&& hook) const -> bool;
 
 private:
   std::shared_ptr<cluster_impl> impl_;

data/ext/couchbase/core/cluster_agent.cxx

@@ -42,11 +42,7 @@ public:
 
   auto free_form_http_request(const http_request& request,
                               free_form_http_request_callback&& callback)
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-    -> tl::expected<std::shared_ptr<pending_operation>, error_union>
-#else
     -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
-#endif
   {
     return http_.do_http_request(request, std::move(callback));
   }
@@ -65,11 +61,7 @@ cluster_agent::cluster_agent(asio::io_context& io, cluster_agent_config config)
 auto
 cluster_agent::free_form_http_request(const couchbase::core::http_request& request,
                                       couchbase::core::free_form_http_request_callback&& callback)
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-  -> tl::expected<std::shared_ptr<pending_operation>, error_union>
-#else
   -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
-#endif
 {
   return impl_->free_form_http_request(request, std::move(callback));
 }

data/ext/couchbase/core/cluster_agent.hxx

@@ -40,11 +40,7 @@ public:
 
   auto free_form_http_request(const http_request& request,
                               free_form_http_request_callback&& callback)
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-    -> tl::expected<std::shared_ptr<pending_operation>, error_union>;
-#else
     -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>;
-#endif
 
 private:
   std::shared_ptr<cluster_agent_impl> impl_;

data/ext/couchbase/core/cluster_options.hxx

@@ -17,16 +17,18 @@
 
 #pragma once
 
-#include "core/columnar/security_options.hxx"
 #include "core/io/dns_config.hxx"
 #include "core/io/ip_protocol.hxx"
 #include "core/metrics/logging_meter_options.hxx"
 #include "core/orphan_reporter.hxx"
+#include "core/row_streamer_options.hxx"
 #include "core/tracing/threshold_logging_options.hxx"
 #include "service_type.hxx"
 #include "timeout_defaults.hxx"
 #include "tls_verify_mode.hxx"
 
+#include "core/protostellar/compression_settings.hxx"
+
 #include <couchbase/metrics/meter.hxx>
 #include <couchbase/retry_strategy.hxx>
 #include <couchbase/tracing/request_tracer.hxx>
@@ -45,7 +47,6 @@ public:
   [[nodiscard]] std::chrono::milliseconds default_timeout_for(service_type type) const;
 
   std::chrono::milliseconds bootstrap_timeout = timeout_defaults::bootstrap_timeout;
-  std::chrono::milliseconds dispatch_timeout = timeout_defaults::dispatch_timeout;
   std::chrono::milliseconds resolve_timeout = timeout_defaults::resolve_timeout;
   std::chrono::milliseconds connect_timeout = timeout_defaults::connect_timeout;
   std::chrono::milliseconds key_value_timeout = timeout_defaults::key_value_timeout;
@@ -71,6 +72,8 @@ public:
   bool enable_unordered_execution{ true };
   bool enable_clustermap_notification{ true };
   bool enable_compression{ true };
+  std::size_t compression_min_size{ 32 };
+  double compression_min_ratio{ 0.83 };
   bool enable_tracing{ true };
   bool enable_metrics{ true };
   bool enable_orphan_reporting{ true };
@@ -96,9 +99,13 @@ public:
   std::string server_group{};
   couchbase::transactions::transactions_config::built transactions{};
 
+  // Writes the whole cluster configuration to the log. It carries the same kinds of values that
+  // are annotated elsewhere in the log, but none of it is annotated here. A tag pair around
+  // multi-line JSON is not a shape the tooling handles, and hashing the blob would remove exactly
+  // what the dump exists to show. Enabling this together with log_redaction is warned about when
+  // the cluster opens.
   bool dump_configuration{ false };
   bool disable_mozilla_ca_certificates{ false };
-  couchbase::core::columnar::security_options security_options{};
 
   bool enable_app_telemetry{ true };
   std::string app_telemetry_endpoint{};
@@ -114,6 +121,22 @@ public:
   bool preserve_bootstrap_nodes_order{ false };
   bool allow_enterprise_analytics{ false };
   bool enable_lazy_connections{ false };
+  bool log_redaction{ false };
+
+  // Tuning for the streaming query/analytics row engine. Internal-only for now (no public API);
+  // sensible static defaults apply unless a core caller overrides them. idle_timeout is derived
+  // per request from the operation timeout, so the value here is not used for it.
+  row_streamer_options streaming{};
 };
 
+[[nodiscard]] inline auto
+make_compression_settings(const cluster_options& options) -> protostellar::kv::compression_settings
+{
+  protostellar::kv::compression_settings compression{};
+  compression.enabled = options.enable_compression;
+  compression.min_size = options.compression_min_size;
+  compression.min_ratio = options.compression_min_ratio;
+  return compression;
+}
+
 } // namespace couchbase::core

data/ext/couchbase/core/collections_component.cxx

@@ -21,6 +21,7 @@
 #include "collections_component_unit_test_api.hxx"
 #include "core/collections_options.hxx"
 #include "core/logger/logger.hxx"
+#include "core/logger/redaction.hxx"
 #include "core/mcbp/big_endian.hxx"
 #include "core/pending_operation.hxx"
 #include "core/protocol/client_opcode.hxx"
@@ -311,6 +312,20 @@ public:
   auto dispatch(std::shared_ptr<mcbp::queue_request> request)
     -> tl::expected<std::shared_ptr<pending_operation>, std::error_code>
   {
+    // Give the KV response path a way to invalidate the cached collection id and re-resolve it
+    // when the server reports unknown_collection (e.g. after a drop/recreate assigns a new id).
+    // Capture weak pointers to both the manager and the request: storing a shared_ptr to the
+    // request inside a std::function held ON that same request would form a self-referential cycle
+    // and leak it. GetCollectionID resolution requests do not pass through here, so they never get
+    // the hook and cannot recurse.
+    request->on_unknown_collection_ = [weak_mgr = weak_from_this(),
+                                       weak_req =
+                                         std::weak_ptr<mcbp::queue_request>(request)]() -> bool {
+      auto mgr = weak_mgr.lock();
+      auto req = weak_req.lock();
+      return (mgr && req) ? mgr->handle_collection_unknown(req) : false;
+    };
+
     if ((request->collection_id_ > 0) // collection id present
         || (request->collection_name_.empty() && request->scope_name_.empty()) // no collection
         || (request->collection_name_ == collection::default_name &&
@@ -350,8 +365,9 @@ collection_id_cache_entry_impl::dispatch(std::shared_ptr<mcbp::queue_request> re
    */
   switch (const std::scoped_lock lock(mutex_); id_) {
     case unknown_collection_id:
-      CB_LOG_DEBUG(
-        "collection {}.{} unknown. refreshing id", req->scope_name_, req->collection_id_);
+      CB_LOG_DEBUG("collection {}.{} unknown. refreshing id",
+                   logger::metadata(req->scope_name_),
+                   logger::metadata(req->collection_name_));
       id_ = pending_collection_id;
 
       if (auto ec = refresh_collection_id(req); ec) {
@@ -362,8 +378,8 @@ collection_id_cache_entry_impl::dispatch(std::shared_ptr<mcbp::queue_request> re
 
     case pending_collection_id:
       CB_LOG_DEBUG("collection {}.{} pending. queueing request OP={}",
-                   req->scope_name_,
-                   req->collection_id_,
+                   logger::metadata(req->scope_name_),
+                   logger::metadata(req->collection_name_),
                    req->command_);
       return queue_->push(req, max_queue_size_);
 
@@ -373,8 +389,8 @@ collection_id_cache_entry_impl::dispatch(std::shared_ptr<mcbp::queue_request> re
 
   if (auto ec = assign_collection_id(req); ec) {
     CB_LOG_DEBUG("failed to set collection ID \"{}.{}\" on request (OP={}): {}",
-                 req->scope_name_,
-                 req->collection_name_,
+                 logger::metadata(req->scope_name_),
+                 logger::metadata(req->collection_name_),
                  req->command_,
                  ec.message());
     return ec;
@@ -391,7 +407,9 @@ collection_id_cache_entry_impl::refresh_collection_id(
     return ec;
   }
 
-  CB_LOG_DEBUG("refreshing collection ID for \"{}.{}\"", req->scope_name_, req->collection_name_);
+  CB_LOG_DEBUG("refreshing collection ID for \"{}.{}\"",
+               logger::metadata(req->scope_name_),
+               logger::metadata(req->collection_name_));
   auto op = manager_.lock()->get_collection_id(
     req->scope_name_,
     req->collection_name_,
@@ -405,8 +423,8 @@ collection_id_cache_entry_impl::refresh_collection_id(
           // queued within the cache. Either the collection will eventually come online or this
           // request will time out.
           CB_LOG_DEBUG("collection \"{}.{}\" not found, attempting retry",
-                       req->scope_name_,
-                       req->collection_name_);
+                       logger::metadata(req->scope_name_),
+                       logger::metadata(req->collection_name_));
           self->set_id(unknown_collection_id);
           if (self->queue_->remove(req)) {
             if (self->manager_.lock()->handle_collection_unknown(req)) {
@@ -416,13 +434,13 @@ collection_id_cache_entry_impl::refresh_collection_id(
             CB_LOG_DEBUG("request no longer existed in op queue, possibly cancelled?, opaque={}, "
                          "collection_name=\"{}\"",
                          req->opaque_,
-                         req->collection_name_);
+                         logger::metadata(req->collection_name_));
           }
         } else {
           CB_LOG_DEBUG("collection id refresh failed: {}, opaque={}, collection_name=\"{}\"",
                        ec.message(),
                        req->opaque_,
-                       req->collection_name_);
+                       logger::metadata(req->collection_name_));
         }
         // There was an error getting this collection ID so lets remove the cache from the manager
         // and try to callback on all the queued requests.
@@ -437,16 +455,16 @@ collection_id_cache_entry_impl::refresh_collection_id(
       // We successfully got the cid, the GetCollectionID itself will have handled setting the ID on
       // this cache, so lets reset the op queue and requeue all of our requests.
       CB_LOG_DEBUG("collection \"{}.{}\" refresh succeeded cid={}, re-queuing requests",
-                   req->scope_name_,
-                   req->collection_name_,
+                   logger::metadata(req->scope_name_),
+                   logger::metadata(req->collection_name_),
                    res.collection_id);
       auto queue = self->swap_queue();
       queue->close();
       return queue->drain([self](const auto& r) {
         if (auto ec = self->assign_collection_id(r); ec) {
           CB_LOG_DEBUG("failed to set collection ID \"{}.{}\" on request (OP={}): {}",
-                       r->scope_name_,
-                       r->collection_name_,
+                       logger::metadata(r->scope_name_),
+                       logger::metadata(r->collection_name_),
                        r->command_,
                        ec.message());
           return;
@@ -461,6 +479,12 @@ collection_id_cache_entry_impl::refresh_collection_id(
   if (op) {
     return {};
   }
+  // The request was queued above so that the resolution could re-dispatch it. No
+  // resolution was started, so nothing will ever drain that queue: take the
+  // request back out and let the caller complete it with this error. Leaving it
+  // queued strands it behind the cache entry, and its callback holds the agent
+  // and the cluster graph behind it.
+  static_cast<void>(queue_->remove(req));
   return op.error();
 }
 

data/ext/couchbase/core/config_profiles.cxx

@@ -64,7 +64,7 @@ config_profiles::config_profiles() noexcept
 void
 config_profiles::apply(std::string_view profile_name, couchbase::core::cluster_options& opts)
 {
-  const std::lock_guard<std::mutex> lock(mut_);
+  const std::scoped_lock<std::mutex> lock(mut_);
   auto it = profiles_.find(profile_name);
   if (it != profiles_.end()) {
     it->second->apply(opts);

data/ext/couchbase/core/crud_component.cxx

@@ -203,12 +203,12 @@ parse_range_scan_documents(gsl::span<std::byte> data,
       }
       body.value = { remaining.begin(),
                      remaining.begin() + static_cast<std::ptrdiff_t>(value_length) };
-      if ((body.datatype & static_cast<std::byte>(protocol::datatype::snappy)) != std::byte{ 0 }) {
+      if (protocol::has_flag(body.datatype, protocol::datatype::snappy)) {
         std::string uncompressed;
         if (snappy::Uncompress(
               reinterpret_cast<const char*>(body.value.data()), body.value.size(), &uncompressed)) {
           body.value = core::utils::to_binary(uncompressed);
-          body.datatype &= ~static_cast<std::byte>(protocol::datatype::snappy);
+          protocol::clear_flag(body.datatype, protocol::datatype::snappy);
         }
       }
       data = gsl::make_span(remaining.data() + value_length, remaining.size() - value_length);

data/ext/couchbase/core/crud_options.hxx

@@ -21,9 +21,11 @@
 #include <couchbase/cas.hxx>
 #include <couchbase/durability_level.hxx>
 #include <couchbase/mutation_token.hxx>
+#include <couchbase/retry_reason.hxx>
 
 #include <chrono>
 #include <optional>
+#include <set>
 #include <string>
 #include <system_error>
 #include <vector>
@@ -65,6 +67,8 @@ public:
 
   struct {
     std::optional<resource_unit_result> resource_units{};
+    std::size_t retry_attempts{ 0 };
+    std::set<retry_reason> retry_reasons{};
   } internal{};
 };
 
@@ -97,6 +101,8 @@ public:
 
   struct {
     std::optional<resource_unit_result> resource_units{};
+    std::size_t retry_attempts{ 0 };
+    std::set<retry_reason> retry_reasons{};
   } internal{};
 };
 
@@ -130,6 +136,8 @@ public:
 
   struct {
     std::optional<resource_unit_result> resource_units{};
+    std::size_t retry_attempts{ 0 };
+    std::set<retry_reason> retry_reasons{};
   } internal{};
 };
 
@@ -163,6 +171,8 @@ public:
 
   struct {
     std::optional<resource_unit_result> resource_units{};
+    std::size_t retry_attempts{ 0 };
+    std::set<retry_reason> retry_reasons{};
   } internal{};
 };
 
@@ -194,6 +204,8 @@ public:
 
   struct {
     std::optional<resource_unit_result> resource_units{};
+    std::size_t retry_attempts{ 0 };
+    std::set<retry_reason> retry_reasons{};
   } internal{};
 };
 
@@ -224,6 +236,8 @@ public:
 
   struct {
     std::optional<resource_unit_result> resource_units{};
+    std::size_t retry_attempts{ 0 };
+    std::set<retry_reason> retry_reasons{};
   } internal{};
 };
 
@@ -259,6 +273,8 @@ public:
 
   struct {
     std::optional<resource_unit_result> resource_units{};
+    std::size_t retry_attempts{ 0 };
+    std::set<retry_reason> retry_reasons{};
   } internal{};
 };
 
@@ -295,6 +311,8 @@ public:
 
   struct {
     std::optional<resource_unit_result> resource_units{};
+    std::size_t retry_attempts{ 0 };
+    std::set<retry_reason> retry_reasons{};
   } internal{};
 };
 
@@ -332,6 +350,8 @@ public:
 
   struct {
     std::optional<resource_unit_result> resource_units{};
+    std::size_t retry_attempts{ 0 };
+    std::set<retry_reason> retry_reasons{};
   } internal{};
 };
 
@@ -364,6 +384,8 @@ public:
 
   struct {
     std::optional<resource_unit_result> resource_units{};
+    std::size_t retry_attempts{ 0 };
+    std::set<retry_reason> retry_reasons{};
   } internal{};
 };
 
@@ -397,6 +419,8 @@ public:
 
   struct {
     std::optional<resource_unit_result> resource_units{};
+    std::size_t retry_attempts{ 0 };
+    std::set<retry_reason> retry_reasons{};
   } internal{};
 };
 
@@ -432,6 +456,8 @@ public:
 
   struct {
     std::optional<resource_unit_result> resource_units{};
+    std::size_t retry_attempts{ 0 };
+    std::set<retry_reason> retry_reasons{};
   } internal{};
 };
 
@@ -462,6 +488,8 @@ public:
 
   struct {
     std::optional<resource_unit_result> resource_units{};
+    std::size_t retry_attempts{ 0 };
+    std::set<retry_reason> retry_reasons{};
   } internal{};
 };
 
@@ -497,6 +525,8 @@ public:
 
   struct {
     std::optional<resource_unit_result> resource_units{};
+    std::size_t retry_attempts{ 0 };
+    std::set<retry_reason> retry_reasons{};
   } internal{};
 };
 
@@ -535,6 +565,8 @@ public:
 
   struct {
     std::optional<resource_unit_result> resource_units{};
+    std::size_t retry_attempts{ 0 };
+    std::set<retry_reason> retry_reasons{};
   } internal{};
 };
 
@@ -573,6 +605,8 @@ public:
 
   struct {
     std::optional<resource_unit_result> resource_units{};
+    std::size_t retry_attempts{ 0 };
+    std::set<retry_reason> retry_reasons{};
   } internal{};
 };
 

data/ext/couchbase/core/crypto/cbcrypto.cc

@@ -21,13 +21,28 @@
 #include <memory>
 #include <stdexcept>
 
-namespace internal
-{
-
+// Platform headers stay at global scope: included inside a namespace, the standard library headers
+// they reach are declared inside it, and std resolves to that namespace's std.
 #ifdef _MSC_VER
 #include <windows.h>
 
 #include <bcrypt.h>
+#elif defined(__APPLE__)
+#include <CommonCrypto/CommonCryptor.h>
+#include <CommonCrypto/CommonDigest.h>
+#include <CommonCrypto/CommonHMAC.h>
+#include <CommonCrypto/CommonKeyDerivation.h>
+#else
+#include "include_ssl/evp.h"
+#include "include_ssl/hmac.h"
+#include "include_ssl/md5.h"
+#include "include_ssl/sha.h"
+#endif
+
+namespace internal
+{
+
+#ifdef _MSC_VER
 
 struct HeapAllocDeleter {
   void operator()(PBYTE bytes)
@@ -335,11 +350,6 @@ decrypt(const couchbase::core::crypto::Cipher /* cipher */,
 
 #elif defined(__APPLE__)
 
-#include <CommonCrypto/CommonCryptor.h>
-#include <CommonCrypto/CommonDigest.h>
-#include <CommonCrypto/CommonHMAC.h>
-#include <CommonCrypto/CommonKeyDerivation.h>
-
 auto
 HMAC_SHA1(std::string_view key, std::string_view data) -> std::string
 {
@@ -589,11 +599,6 @@ decrypt(const couchbase::core::crypto::Cipher cipher,
 
 #else
 
-#include "include_ssl/evp.h"
-#include "include_ssl/hmac.h"
-#include "include_ssl/md5.h"
-#include "include_ssl/sha.h"
-
 // OpenSSL
 
 auto

data/ext/couchbase/core/document_id_redaction.hxx

@@ -0,0 +1,81 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+/*
+ * The logging formatter for a document id, kept out of document_id_fmt.hxx so that the plain
+ * formatter stays free of the logger. That header is included by transaction internals, a subdoc
+ * test and the FIT performer, none of which log a document id; only the handful of files that pass
+ * one to a CB_LOG_* statement include this.
+ */
+
+#pragma once
+
+#include "document_id_fmt.hxx"
+#include "logger/redaction.hxx"
+
+#include <spdlog/fmt/bundled/core.h>
+
+namespace couchbase::core::logger
+{
+struct redacted_document_id {
+  const document_id& value;
+};
+
+/**
+ * Tag a document id for logging. It renders as bucket/scope.collection/key, and those parts do not
+ * share a redaction category: the names are metadata and only the key is user data. Wrapping the
+ * rendered form as a whole would put a bucket name inside a <ud> span, and the span would hash to
+ * something that matches no other log line.
+ *
+ * The plain formatter in document_id_fmt.hxx is left alone on purpose, since it is also used
+ * outside logging.
+ */
+inline auto
+document(const document_id& value) -> redacted_document_id
+{
+  return { value };
+}
+} // namespace couchbase::core::logger
+
+template<>
+struct fmt::formatter<couchbase::core::logger::redacted_document_id> {
+  template<typename ParseContext>
+  constexpr auto parse(ParseContext& ctx)
+  {
+    return ctx.begin();
+  }
+
+  template<typename FormatContext>
+  auto format(const couchbase::core::logger::redacted_document_id& redacted,
+              FormatContext& ctx) const
+  {
+    namespace logger = couchbase::core::logger;
+    const auto& id = redacted.value;
+    // An id built without a collection carries an empty collection path, and renders with an empty
+    // middle component. Keep that shape rather than joining an empty scope and collection.
+    if (id.collection_path().empty()) {
+      return format_to(
+        ctx.out(), "{}//{}", logger::metadata(id.bucket()), logger::user_data(id.key()));
+    }
+    return format_to(ctx.out(),
+                     "{}/{}.{}/{}",
+                     logger::metadata(id.bucket()),
+                     logger::metadata(id.scope()),
+                     logger::metadata(id.collection()),
+                     logger::user_data(id.key()));
+  }
+};

data/ext/couchbase/core/error_context/base_error_context.hxx

@@ -66,12 +66,13 @@ public:
                      std::optional<std::string> last_dispatched_from,
                      std::size_t retry_attempts,
                      std::set<retry_reason> retry_reasons)
-    : operation_id_{ std::move(operation_id) }
-    , ec_{ ec }
-    , last_dispatched_to_{ std::move(last_dispatched_to) }
-    , last_dispatched_from_{ std::move(last_dispatched_from) }
-    , retry_attempts_{ retry_attempts }
-    , retry_reasons_{ std::move(retry_reasons) }
+    : base_error_context{ std::move(operation_id),
+                          ec,
+                          std::move(last_dispatched_to),
+                          std::move(last_dispatched_from),
+                          retry_attempts,
+                          std::move(retry_reasons),
+                          couchbase::node_id{} }
   {
   }