couchbase 4.4.2 → 4.4.4

package/deps/couchbase-cxx-client/core/impl/collection.cxx

@@ -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,8 +213,9 @@ public:
         expiry,
         options.timeout,
         { options.retry_strategy },
+        options.parent_span,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [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)](
@@ -1390,7 +1414,7 @@ collection::scan(const couchbase::scan_type& scan_type, const couchbase::scan_op
 {
   auto barrier = std::make_shared<std::promise<std::pair<error, scan_result>>>();
   auto future = barrier->get_future();
-  scan(scan_type, options, [barrier](auto err, auto result) {
+  scan(scan_type, options, [barrier](const auto& err, auto result) {
     barrier->set_value({ err, std::move(result) });
   });
   return future;

package/deps/couchbase-cxx-client/core/impl/collection_manager.cxx

@@ -101,7 +101,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -122,7 +122,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -143,7 +143,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -173,7 +173,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -189,7 +189,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }

package/deps/couchbase-cxx-client/core/impl/error.cxx

@@ -115,59 +115,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();
 }

package/deps/couchbase-cxx-client/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{};

package/deps/couchbase-cxx-client/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{};

package/deps/couchbase-cxx-client/core/impl/observe_poll.cxx

@@ -26,6 +26,7 @@
 
 #include <memory>
 #include <mutex>
+#include <system_error>
 
 namespace couchbase::core::impl
 {
@@ -240,8 +241,7 @@ public:
   void handle_response(observe_seqno_response&& response)
   {
     --expect_number_of_responses_;
-    auto r = std::move(response);
-    status_.examine(r);
+    status_.examine(response);
     maybe_finish();
   }
 
@@ -249,6 +249,8 @@ public:
   {
     poll_backoff_.cancel();
     poll_deadline_.cancel();
+    on_last_response(0, [](std::error_code) {
+    });
     observe_handler handler{};
     {
       const std::scoped_lock lock(handler_mutex_);
@@ -268,10 +270,16 @@ public:
         return;
       }
       if (status_.meets_condition(persist_to_, replicate_to_)) {
+        poll_backoff_.cancel();
+        poll_deadline_.cancel();
+        on_last_response(0, [](std::error_code) {
+        });
         std::swap(handler_, handler);
-      } else if (expect_number_of_responses_ == 0 && on_last_response_) {
-        poll_backoff_.expires_after(poll_backoff_interval_);
-        return poll_backoff_.async_wait(std::move(on_last_response_));
+      } else if (expect_number_of_responses_ == 0) {
+        if (auto on_last_response = std::move(on_last_response_); on_last_response) {
+          poll_backoff_.expires_after(poll_backoff_interval_);
+          return poll_backoff_.async_wait(std::move(on_last_response));
+        }
       }
     }
     if (handler) {

package/deps/couchbase-cxx-client/core/impl/observe_poll.hxx

@@ -17,7 +17,6 @@
 
 #pragma once
 
-#include "core/error_context/key_value_error_context.hxx"
 #include <couchbase/mutation_token.hxx>
 #include <couchbase/persist_to.hxx>
 #include <couchbase/replicate_to.hxx>
@@ -26,8 +25,7 @@
 #include "core/utils/movable_function.hxx"
 
 #include <chrono>
-#include <functional>
-#include <memory>
+#include <system_error>
 
 namespace couchbase::core
 {

package/deps/couchbase-cxx-client/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{};

package/deps/couchbase-cxx-client/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);

package/deps/couchbase-cxx-client/core/impl/query_index_manager.cxx

@@ -232,7 +232,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -259,7 +259,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -283,7 +283,7 @@ public:
         {},
         options.timeout,
       },
-      [handler = std::move(handler)](auto resp) {
+      [handler = std::move(handler)](const auto& resp) {
         handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -342,7 +342,7 @@ public:
                                                                    std::move(list_resp.index_names),
                                                                    {},
                                                                    timeout },
-          [handler = std::move(handler)](auto build_resp) {
+          [handler = std::move(handler)](const auto& build_resp) {
             return handler(core::impl::make_error(build_resp.ctx));
           });
       });
@@ -390,7 +390,7 @@ query_index_manager::get_all_indexes(const std::string& bucket_name,
   auto barrier =
     std::make_shared<std::promise<std::pair<error, std::vector<management::query_index>>>>();
   auto future = barrier->get_future();
-  get_all_indexes(bucket_name, options, [barrier](auto err, auto resp) mutable {
+  get_all_indexes(bucket_name, options, [barrier](auto err, const auto& resp) mutable {
     barrier->set_value({ std::move(err), resp });
   });
   return future;
@@ -563,7 +563,7 @@ collection_query_index_manager::get_all_indexes(const get_all_query_indexes_opti
   auto barrier =
     std::make_shared<std::promise<std::pair<error, std::vector<management::query_index>>>>();
   auto future = barrier->get_future();
-  get_all_indexes(options, [barrier](auto err, auto resp) mutable {
+  get_all_indexes(options, [barrier](auto err, const auto& resp) mutable {
     barrier->set_value({ std::move(err), resp });
   });
   return future;

package/deps/couchbase-cxx-client/core/impl/scan_result.cxx

@@ -97,7 +97,7 @@ scan_result::next() const -> std::future<std::pair<error, std::optional<scan_res
 {
   auto barrier =
     std::make_shared<std::promise<std::pair<error, std::optional<scan_result_item>>>>();
-  internal_->next([barrier](auto err, auto item) mutable {
+  internal_->next([barrier](const auto& err, const auto& item) mutable {
     barrier->set_value({ err, item });
   });
   return barrier->get_future();

package/deps/couchbase-cxx-client/core/impl/search.cxx

@@ -165,6 +165,7 @@ build_search_request(std::string index_name,
     options.client_context_id,
     options.timeout,
   };
+  request.parent_span = options.parent_span;
   return request;
 }
 
@@ -207,6 +208,7 @@ build_search_request(std::string index_name,
     options.client_context_id,
     options.timeout,
   };
+  core_request.parent_span = options.parent_span;
 
   if (auto vector_search = request.vector_search(); vector_search.has_value()) {
     core_request.vector_search = core::utils::json::generate_binary(vector_search->query);

package/deps/couchbase-cxx-client/core/impl/search_index_manager.cxx

@@ -150,7 +150,7 @@ public:
     core_.execute(
       core::operations::management::search_index_get_request{
         std::move(index_name), bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx), map_search_index(resp.index));
       });
   }
@@ -161,7 +161,7 @@ public:
     core_.execute(
       core::operations::management::search_index_get_all_request{
         bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx), map_all_search_indexes(resp.indexes));
       });
   }
@@ -173,7 +173,7 @@ public:
     core_.execute(
       core::operations::management::search_index_upsert_request{
         map_search_index(search_index), bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -185,7 +185,7 @@ public:
     core_.execute(
       core::operations::management::search_index_drop_request{
         std::move(index_name), bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -197,7 +197,7 @@ public:
     core_.execute(
       core::operations::management::search_index_get_documents_count_request{
         std::move(index_name), bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx), resp.count);
       });
   }
@@ -209,7 +209,7 @@ public:
     core_.execute(
       core::operations::management::search_index_control_ingest_request{
         std::move(index_name), true, bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -221,7 +221,7 @@ public:
     core_.execute(
       core::operations::management::search_index_control_ingest_request{
         std::move(index_name), false, bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -233,7 +233,7 @@ public:
     core_.execute(
       core::operations::management::search_index_control_query_request{
         std::move(index_name), true, bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -245,7 +245,7 @@ public:
     core_.execute(
       core::operations::management::search_index_control_query_request{
         std::move(index_name), false, bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -257,7 +257,7 @@ public:
     core_.execute(
       core::operations::management::search_index_control_plan_freeze_request{
         std::move(index_name), true, bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -269,7 +269,7 @@ public:
     core_.execute(
       core::operations::management::search_index_control_plan_freeze_request{
         std::move(index_name), false, bucket_name_, scope_name_, {}, options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx));
       });
   }
@@ -286,7 +286,7 @@ public:
                                                                            scope_name_,
                                                                            {},
                                                                            options.timeout },
-      [handler = std::move(handler)](auto resp) mutable {
+      [handler = std::move(handler)](const auto& resp) mutable {
         return handler(core::impl::make_error(resp.ctx), convert_analysis(resp.analysis));
       });
   }