couchbase 3.5.4 → 3.5.6

data/ext/couchbase/core/impl/cluster.cxx

@@ -79,8 +79,8 @@ cluster::cluster(std::shared_ptr<cluster_impl> impl)
 namespace
 {
 auto
-options_to_origin(const std::string& connection_string,
-                  const couchbase::cluster_options& options) -> core::origin
+options_to_origin(const std::string& connection_string, const couchbase::cluster_options& options)
+  -> core::origin
 {
   auto opts = options.build();
 
@@ -215,12 +215,27 @@ fork_event_to_asio(fork_event event) -> asio::execution_context::fork_event
 class cluster_impl : public std::enable_shared_from_this<cluster_impl>
 {
 public:
-  cluster_impl() = default;
+  cluster_impl(std::string connection_string, cluster_options options)
+    : connection_string_{ std::move(connection_string) }
+    , options_{ std::move(options) }
+  {
+  }
+
   cluster_impl(const cluster_impl&) = delete;
   cluster_impl(cluster_impl&&) = delete;
   auto operator=(const cluster_impl&) = delete;
   auto operator=(cluster_impl&&) = delete;
 
+  [[nodiscard]] auto connection_string() const -> const std::string&
+  {
+    return connection_string_;
+  }
+
+  [[nodiscard]] auto options() const -> const cluster_options&
+  {
+    return options_;
+  }
+
   ~cluster_impl()
   {
     std::promise<void> barrier;
@@ -238,12 +253,10 @@ public:
     future.get();
   }
 
-  void open(const std::string& connection_string,
-            const cluster_options& options,
-            cluster_connect_handler&& handler)
+  void open(cluster_connect_handler&& handler)
   {
     core_.open(
-      options_to_origin(connection_string, options),
+      options_to_origin(connection_string_, options_),
       [impl = shared_from_this(), handler = std::move(handler)](std::error_code ec) mutable {
         if (ec) {
           return handler(ec, {});
@@ -350,7 +363,7 @@ public:
     }
     io_.notify_fork(fork_event_to_asio(event));
 
-    if (transactions_) {
+    if (event != fork_event::child && transactions_) {
       transactions_->notify_fork(event);
     }
   }
@@ -393,6 +406,8 @@ private:
     }
   }
 
+  std::string connection_string_;
+  cluster_options options_;
   asio::io_context io_{ ASIO_CONCURRENCY_HINT_SAFE };
   core::cluster core_{ io_ };
   std::shared_ptr<core::transactions::transactions> transactions_{ nullptr };
@@ -423,8 +438,8 @@ cluster::query(std::string statement, const query_options& options, query_handle
 }
 
 auto
-cluster::query(std::string statement,
-               const query_options& options) const -> std::future<std::pair<error, query_result>>
+cluster::query(std::string statement, const query_options& options) const
+  -> std::future<std::pair<error, query_result>>
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, query_result>>>();
   auto future = barrier->get_future();
@@ -500,9 +515,8 @@ cluster::search(std::string index_name,
 }
 
 auto
-cluster::search(std::string index_name,
-                search_request request,
-                const search_options& options) const -> std::future<std::pair<error, search_result>>
+cluster::search(std::string index_name, search_request request, const search_options& options) const
+  -> std::future<std::pair<error, search_result>>
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, search_result>>>();
   search(
@@ -513,8 +527,8 @@ cluster::search(std::string index_name,
 }
 
 auto
-cluster::connect(const std::string& connection_string,
-                 const cluster_options& options) -> std::future<std::pair<error, cluster>>
+cluster::connect(const std::string& connection_string, const cluster_options& options)
+  -> std::future<std::pair<error, cluster>>
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, cluster>>>();
   auto future = barrier->get_future();
@@ -535,8 +549,8 @@ cluster::connect(const std::string& connection_string,
     auto barrier = std::make_shared<std::promise<std::pair<error, cluster>>>();
     auto future = barrier->get_future();
     {
-      auto impl = std::make_shared<cluster_impl>();
-      impl->open(connection_string, options, [barrier](auto err, auto c) {
+      auto impl = std::make_shared<cluster_impl>(connection_string, options);
+      impl->open([barrier](auto err, auto c) {
         barrier->set_value({ std::move(err), std::move(c) });
       });
     }
@@ -552,7 +566,30 @@ cluster::notify_fork(fork_event event) -> void
   if (!impl_) {
     return;
   }
-  return impl_->notify_fork(event);
+  impl_->notify_fork(event);
+  if (event != fork_event::child) {
+    return;
+  }
+
+  auto new_impl = std::make_shared<cluster_impl>(impl_->connection_string(), impl_->options());
+  impl_.reset();
+
+  {
+    auto barrier = std::make_shared<std::promise<void>>();
+    auto future = barrier->get_future();
+
+    new_impl->open([this, barrier, new_impl](const auto& err, const auto& /* c */) {
+      if (err.ec()) {
+        // TODO(SA): we should fall to background reconnect loop similar to Columnar build
+        CB_LOG_ERROR("Unable to reconnect instance after fork: {}", err.ec().message());
+        return;
+      }
+      impl_ = new_impl;
+      barrier->set_value();
+    });
+
+    future.get();
+  }
 }
 
 void

data/ext/couchbase/core/impl/collection.cxx

@@ -90,7 +90,7 @@
 #include <couchbase/unlock_options.hxx>
 #include <couchbase/upsert_options.hxx>
 
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <chrono>
 #include <cstdint>
@@ -149,6 +149,7 @@ public:
           {},
           options.timeout,
           { options.retry_strategy },
+          options.parent_span,
         },
         [handler = std::move(handler)](auto resp) mutable {
           return handler(core::impl::make_error(std::move(resp.ctx)),
@@ -166,6 +167,7 @@ public:
         false,
         options.timeout,
         { options.retry_strategy },
+        options.parent_span,
       },
       [handler = std::move(handler)](auto resp) mutable {
         std::optional<std::chrono::system_clock::time_point> expiry_time{};
@@ -190,6 +192,7 @@ public:
         expiry,
         options.timeout,
         { options.retry_strategy },
+        options.parent_span,
       },
       [handler = std::move(handler)](auto resp) mutable {
         return handler(core::impl::make_error(std::move(resp.ctx)),
@@ -210,6 +213,7 @@ public:
         expiry,
         options.timeout,
         { options.retry_strategy },
+        options.parent_span,
       },
       [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(std::move(resp.ctx)), result{ resp.cas });
@@ -279,6 +283,7 @@ public:
           options.durability_level,
           options.timeout,
           { options.retry_strategy },
+          options.parent_span,
         },
         [handler = std::move(handler)](auto resp) mutable {
           if (resp.ctx.ec()) {
@@ -290,7 +295,14 @@ public:
     }
 
     core::operations::remove_request request{
-      id, {}, {}, options.cas, durability_level::none, options.timeout, { options.retry_strategy },
+      id,
+      {},
+      {},
+      options.cas,
+      durability_level::none,
+      options.timeout,
+      { options.retry_strategy },
+      options.parent_span,
     };
     return core_.execute(std::move(request),
                          [core = core_, id = std::move(id), options, handler = std::move(handler)](
@@ -332,6 +344,7 @@ public:
         static_cast<uint32_t>(lock_duration.count()),
         options.timeout,
         { options.retry_strategy },
+        options.parent_span,
       },
       [handler = std::move(handler)](auto&& resp) mutable {
         return handler(core::impl::make_error(std::move(resp.ctx)),
@@ -352,6 +365,7 @@ public:
         cas,
         options.timeout,
         { options.retry_strategy },
+        options.parent_span,
       },
       [handler = std::move(handler)](auto&& resp) mutable {
         return handler(core::impl::make_error(std::move(resp.ctx)));
@@ -369,6 +383,7 @@ public:
         {},
         options.timeout,
         { options.retry_strategy },
+        options.parent_span,
       },
       [handler = std::move(handler)](auto&& resp) mutable {
         return handler(core::impl::make_error(std::move(resp.ctx)),
@@ -395,6 +410,7 @@ public:
         specs,
         options.timeout,
         { options.retry_strategy },
+        options.parent_span,
       },
       [handler = std::move(handler)](auto resp) mutable {
         if (resp.ctx.ec()) {
@@ -427,7 +443,7 @@ public:
         core::document_id{ bucket_name_, scope_name_, name_, std::move(document_key) },
         specs,
         options.timeout,
-        {},
+        options.parent_span,
         options.read_preference,
       },
       [handler = std::move(handler)](auto resp) mutable {
@@ -465,7 +481,7 @@ public:
         core::document_id{ bucket_name_, scope_name_, name_, std::move(document_key) },
         specs,
         options.timeout,
-        {},
+        options.parent_span,
         options.read_preference,
       },
       [handler = std::move(handler)](auto resp) mutable {
@@ -514,6 +530,7 @@ public:
           options.timeout,
           { options.retry_strategy },
           options.preserve_expiry,
+          options.parent_span,
         },
         [handler = std::move(handler)](auto resp) mutable {
           if (resp.ctx.ec()) {
@@ -548,6 +565,7 @@ public:
       options.timeout,
       { options.retry_strategy },
       options.preserve_expiry,
+      options.parent_span,
     };
     return core_.execute(
       std::move(request),
@@ -611,6 +629,7 @@ public:
           options.timeout,
           { options.retry_strategy },
           options.preserve_expiry,
+          options.parent_span,
         },
         [handler = std::move(handler)](auto resp) mutable {
           return handler(core::impl::make_error(std::move(resp.ctx)),
@@ -629,6 +648,7 @@ public:
       options.timeout,
       { options.retry_strategy },
       options.preserve_expiry,
+      options.parent_span,
     };
     return core_.execute(
       std::move(request),
@@ -681,6 +701,7 @@ public:
           options.durability_level,
           options.timeout,
           { options.retry_strategy },
+          options.parent_span,
         },
         [handler = std::move(handler)](auto&& resp) mutable {
           if (resp.ctx.ec()) {
@@ -701,6 +722,7 @@ public:
       durability_level::none,
       options.timeout,
       { options.retry_strategy },
+      options.parent_span,
     };
     return core_.execute(
       std::move(request),
@@ -754,6 +776,7 @@ public:
           options.timeout,
           { options.retry_strategy },
           options.preserve_expiry,
+          options.parent_span,
         },
         [handler = std::move(handler)](auto resp) mutable {
           if (resp.ctx.ec()) {
@@ -776,6 +799,7 @@ public:
       options.timeout,
       { options.retry_strategy },
       options.preserve_expiry,
+      options.parent_span,
     };
     return core_.execute(std::move(request),
                          [core = core_, id = std::move(id), options, handler = std::move(handler)](
@@ -860,13 +884,14 @@ public:
         return core_.with_bucket_configuration(
           bucket_name_,
           [this, handler = std::move(handler), orchestrator_opts, core_scan_type](
-            std::error_code ec, const core::topology::configuration& config) mutable {
+            std::error_code ec,
+            const std::shared_ptr<core::topology::configuration>& config) mutable {
             if (ec) {
               return handler(
                 error(ec, "An error occurred when attempting to fetch the bucket configuration."),
                 {});
             }
-            if (!config.capabilities.supports_range_scan()) {
+            if (!config->capabilities.supports_range_scan()) {
               return handler(error(errc::common::feature_not_available,
                                    "This bucket does not support range scan."),
                              {});
@@ -889,7 +914,7 @@ public:
                         bucket_name_)),
                 {});
             }
-            if (!config.vbmap.has_value() || config.vbmap->empty()) {
+            if (!config->vbmap.has_value() || config->vbmap->empty()) {
               CB_LOG_WARNING("Unable to get vbucket map for `{}` - cannot perform scan operation",
                              bucket_name_);
               return handler(error(errc::common::request_canceled,
@@ -899,7 +924,7 @@ public:
 
             auto orchestrator = core::range_scan_orchestrator(core_.io_context(),
                                                               agent.value(),
-                                                              config.vbmap.value(),
+                                                              config->vbmap.value(),
                                                               scope_name_,
                                                               name_,
                                                               core_scan_type,
@@ -969,8 +994,8 @@ collection::get(std::string document_id, const get_options& options, get_handler
 }
 
 auto
-collection::get(std::string document_id,
-                const get_options& options) const -> std::future<std::pair<error, get_result>>
+collection::get(std::string document_id, const get_options& options) const
+  -> std::future<std::pair<error, get_result>>
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, get_result>>>();
   auto future = barrier->get_future();
@@ -1272,9 +1297,8 @@ collection::unlock(std::string document_id,
 }
 
 auto
-collection::unlock(std::string document_id,
-                   couchbase::cas cas,
-                   const unlock_options& options) const -> std::future<error>
+collection::unlock(std::string document_id, couchbase::cas cas, const unlock_options& options) const
+  -> std::future<error>
 {
   auto barrier = std::make_shared<std::promise<error>>();
   auto future = barrier->get_future();
@@ -1385,8 +1409,9 @@ collection::scan(const couchbase::scan_type& scan_type,
 }
 
 auto
-collection::scan(const couchbase::scan_type& scan_type, const couchbase::scan_options& options)
-  const -> std::future<std::pair<error, scan_result>>
+collection::scan(const couchbase::scan_type& scan_type,
+                 const couchbase::scan_options& options) const
+  -> std::future<std::pair<error, scan_result>>
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, scan_result>>>();
   auto future = barrier->get_future();

data/ext/couchbase/core/impl/date_range.cxx

@@ -17,8 +17,8 @@
 
 #include <couchbase/date_range.hxx>
 
-#include <fmt/chrono.h>
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/chrono.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <chrono>
 #include <ctime>

data/ext/couchbase/core/impl/date_range_query.cxx

@@ -21,8 +21,8 @@
 
 #include <couchbase/error_codes.hxx>
 
-#include <fmt/chrono.h>
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/chrono.h>
+#include <spdlog/fmt/bundled/core.h>
 #include <tao/json/type.hpp>
 
 #include <chrono>

data/ext/couchbase/core/impl/dns_srv_tracker.cxx

@@ -31,7 +31,7 @@
 #include <asio/bind_executor.hpp>
 #include <asio/io_context.hpp>
 #include <asio/post.hpp>
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <functional>
 #include <memory>

data/ext/couchbase/core/impl/error.cxx

@@ -36,14 +36,16 @@
 #include "core/impl/internal_error_context.hxx"
 #include "core/transactions/exceptions.hxx"
 #include "core/transactions/internal/exceptions_internal.hxx"
-#include "core/transactions/internal/exceptions_internal_fmt.hxx"
 
 #include <couchbase/error.hxx>
 #include <couchbase/error_codes.hxx>
 #include <couchbase/error_context.hxx>
 
+#include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 
+#include "core/transactions/internal/exceptions_internal_fmt.hxx"
+
 #include <memory>
 #include <optional>
 #include <string>
@@ -115,59 +117,80 @@ namespace core::impl
 auto
 make_error(const core::error_context::query& core_ctx) -> error
 {
+  if (!core_ctx.ec) {
+    return {};
+  }
   return { core_ctx.ec, {}, internal_error_context::build_error_context(core_ctx) };
 }
 
 auto
 make_error(const query_error_context& core_ctx) -> error
 {
+  if (!core_ctx.ec()) {
+    return {};
+  }
   return { core_ctx.ec(), {}, internal_error_context::build_error_context(core_ctx) };
 }
 
 auto
 make_error(const core::error_context::search& core_ctx) -> error
 {
+  if (!core_ctx.ec) {
+    return {};
+  }
   return { core_ctx.ec, {}, internal_error_context::build_error_context(core_ctx) };
 }
 
 auto
 make_error(const core::error_context::analytics& core_ctx) -> error
 {
+  if (!core_ctx.ec) {
+    return {};
+  }
   return { core_ctx.ec, {}, internal_error_context::build_error_context(core_ctx) };
 }
 
 auto
 make_error(const core::error_context::http& core_ctx) -> error
 {
+  if (!core_ctx.ec) {
+    return {};
+  }
   return { core_ctx.ec, {}, internal_error_context::build_error_context(core_ctx) };
 }
 
 auto
 make_error(const couchbase::core::key_value_error_context& core_ctx) -> error
 {
+  if (!core_ctx.ec()) {
+    return {};
+  }
   return { core_ctx.ec(), {}, internal_error_context::build_error_context(core_ctx) };
 }
 
 auto
 make_error(const couchbase::core::subdocument_error_context& core_ctx) -> error
 {
+  if (!core_ctx.ec()) {
+    return {};
+  }
   return { core_ctx.ec(), {}, internal_error_context::build_error_context(core_ctx) };
 }
 
 auto
 make_error(const couchbase::core::transaction_error_context& ctx) -> error
 {
-  return { ctx.ec(), "", {}, { ctx.cause() } };
+  return { ctx.ec(), {}, {}, { ctx.cause() } };
 }
 
 auto
 make_error(const couchbase::core::transaction_op_error_context& ctx) -> error
 {
   if (std::holds_alternative<key_value_error_context>(ctx.cause())) {
-    return { ctx.ec(), "", {}, make_error(std::get<key_value_error_context>(ctx.cause())) };
+    return { ctx.ec(), {}, {}, make_error(std::get<key_value_error_context>(ctx.cause())) };
   }
   if (std::holds_alternative<query_error_context>(ctx.cause())) {
-    return { ctx.ec(), "", {}, make_error(std::get<query_error_context>(ctx.cause())) };
+    return { ctx.ec(), {}, {}, make_error(std::get<query_error_context>(ctx.cause())) };
   }
   return ctx.ec();
 }

data/ext/couchbase/core/impl/expiry.cxx

@@ -18,8 +18,8 @@
 #include <couchbase/error_codes.hxx>
 #include <couchbase/expiry.hxx>
 
-#include <fmt/chrono.h>
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/chrono.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <chrono>
 #include <cstdint>

data/ext/couchbase/core/impl/fail_fast_retry_strategy.cxx

@@ -20,8 +20,7 @@
 #include <couchbase/retry_reason.hxx>
 #include <couchbase/retry_request.hxx>
 
-#include <fmt/core.h>
-#include <fmt/format.h>
+#include <spdlog/fmt/bundled/format.h>
 
 #include <memory>
 #include <string>

data/ext/couchbase/core/impl/get_replica.hxx

@@ -41,6 +41,8 @@ struct get_replica_request {
   using encoded_response_type =
     core::protocol::client_response<core::protocol::get_replica_response_body>;
 
+  static const inline std::string observability_identifier = "get_replica";
+
   core::document_id id;
   std::optional<std::chrono::milliseconds> timeout{};
   std::uint16_t partition{};

data/ext/couchbase/core/impl/key_value_error_context.cxx

@@ -15,14 +15,16 @@
  *   limitations under the License.
  */
 
-#include <couchbase/fmt/cas.hxx>
-#include <couchbase/fmt/retry_reason.hxx>
-
 #include "core/error_context/key_value_error_context.hxx"
+
+#include <spdlog/fmt/bundled/core.h>
+#include <tao/json/to_string.hpp>
+
 #include "core/fmt/key_value_error_map_attribute.hxx"
 #include "core/fmt/key_value_status_code.hxx"
 
-#include <tao/json/to_string.hpp>
+#include <couchbase/fmt/cas.hxx>
+#include <couchbase/fmt/retry_reason.hxx>
 
 namespace couchbase::core
 {

data/ext/couchbase/core/impl/lookup_in_replica.hxx

@@ -53,6 +53,8 @@ struct lookup_in_replica_request {
   using encoded_response_type =
     protocol::client_response<protocol::lookup_in_replica_response_body>;
 
+  static const inline std::string observability_identifier = "lookup_in_replica";
+
   document_id id;
   std::vector<couchbase::core::impl::subdoc::command> specs{};
   std::optional<std::chrono::milliseconds> timeout{};

data/ext/couchbase/core/impl/numeric_range.cxx

@@ -17,7 +17,7 @@
 
 #include <couchbase/numeric_range.hxx>
 
-#include <fmt/chrono.h>
+#include <spdlog/fmt/bundled/chrono.h>
 
 namespace couchbase
 {

data/ext/couchbase/core/impl/observe_poll.cxx

@@ -96,24 +96,24 @@ number_of_replica_nodes_required(couchbase::replicate_to replicate_to) -> std::u
 }
 
 auto
-validate_replicas(const topology::configuration& config,
+validate_replicas(const std::shared_ptr<topology::configuration>& config,
                   couchbase::persist_to persist_to,
                   couchbase::replicate_to replicate_to) -> std::pair<std::error_code, std::uint32_t>
 {
-  if (config.node_locator != topology::configuration::node_locator_type::vbucket) {
+  if (config->node_locator != topology::configuration::node_locator_type::vbucket) {
     return { errc::common::feature_not_available, {} };
   }
 
   if (touches_replica(persist_to, replicate_to)) {
-    if (!config.num_replicas) {
+    auto number_of_replicas = config->num_replicas;
+    if (!number_of_replicas.has_value()) {
       return { errc::key_value::durability_impossible, {} };
     }
-    auto number_of_replicas = config.num_replicas.value();
     if (number_of_replica_nodes_required(persist_to) > number_of_replicas ||
         number_of_replica_nodes_required(replicate_to) > number_of_replicas) {
       return { errc::key_value::durability_impossible, {} };
     }
-    return { {}, number_of_replicas };
+    return { {}, number_of_replicas.value() };
   }
   return { {}, 0 };
 }
@@ -335,8 +335,8 @@ observe_poll(const cluster& core, std::shared_ptr<observe_context> ctx)
   const std::string bucket_name = ctx->bucket_name();
   core.with_bucket_configuration(
     bucket_name,
-    [core, ctx = std::move(ctx)](std::error_code ec,
-                                 const core::topology::configuration& config) mutable {
+    [core, ctx = std::move(ctx)](
+      std::error_code ec, const std::shared_ptr<core::topology::configuration>& config) mutable {
       if (ec) {
         return ctx->finish(ec);
       }

data/ext/couchbase/core/impl/observe_seqno.hxx

@@ -50,6 +50,8 @@ struct observe_seqno_request {
   using encoded_response_type =
     core::protocol::client_response<core::protocol::observe_seqno_response_body>;
 
+  static const inline std::string observability_identifier = "observe_seqno";
+
   core::document_id id;
   bool active{};
   std::uint64_t partition_uuid{};

data/ext/couchbase/core/impl/query.cxx

@@ -180,6 +180,7 @@ build_query_request(std::string statement,
     std::move(query_context), std::move(options.client_context_id),
     options.timeout,          options.profile,
   };
+  request.parent_span = options.parent_span;
   if (!options.raw.empty()) {
     for (auto& [name, value] : options.raw) {
       request.raw[name] = std::move(value);

data/ext/couchbase/core/impl/query_error_context.cxx

@@ -15,12 +15,13 @@
  *   limitations under the License.
  */
 
-#include <couchbase/fmt/retry_reason.hxx>
-
 #include "core/error_context/query_error_context.hxx"
 
+#include <spdlog/fmt/bundled/core.h>
 #include <tao/json/to_string.hpp>
 
+#include <couchbase/fmt/retry_reason.hxx>
+
 namespace couchbase::core
 {
 auto