couchbase 3.5.6 → 3.6.0

data/ext/couchbase/core/http_component.cxx

@@ -155,6 +155,9 @@ public:
     if (!callback_) {
       return;
     }
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    dispatch_deadline_.cancel();
+#endif
     session_ = std::move(session);
 
     auto start_op = [self = shared_from_this()]() {
@@ -344,6 +347,9 @@ public:
     if (!callback_) {
       return;
     }
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    dispatch_deadline_.cancel();
+#endif
     session_ = std::move(session);
 
     session_->write_and_subscribe(

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

@@ -96,6 +96,7 @@ public:
           std::move(data),
           {},
           {},
+          options.cas,
           options.durability_level,
           options.timeout,
           { options.retry_strategy },
@@ -114,6 +115,7 @@ public:
       std::move(data),
       {},
       {},
+      options.cas,
       durability_level::none,
       options.timeout,
       { options.retry_strategy },
@@ -165,6 +167,7 @@ public:
           std::move(data),
           {},
           {},
+          options.cas,
           options.durability_level,
           options.timeout,
           { options.retry_strategy },
@@ -183,6 +186,7 @@ public:
       std::move(data),
       {},
       {},
+      options.cas,
       durability_level::none,
       options.timeout,
       { options.retry_strategy },

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

@@ -61,6 +61,7 @@ map_bucket_settings(const couchbase::core::management::cluster::bucket_settings&
   bucket_settings.flush_enabled = bucket.flush_enabled;
   bucket_settings.history_retention_bytes = bucket.history_retention_bytes;
   bucket_settings.history_retention_duration = bucket.history_retention_duration;
+  bucket_settings.num_vbuckets = bucket.num_vbuckets;
   switch (bucket.conflict_resolution_type) {
     case core::management::cluster::bucket_conflict_resolution::unknown:
       bucket_settings.conflict_resolution_type =
@@ -169,6 +170,7 @@ map_bucket_settings(const couchbase::management::cluster::bucket_settings& bucke
     bucket.history_retention_collection_default;
   bucket_settings.history_retention_bytes = bucket.history_retention_bytes;
   bucket_settings.history_retention_duration = bucket.history_retention_duration;
+  bucket_settings.num_vbuckets = bucket.num_vbuckets;
   switch (bucket.conflict_resolution_type) {
     case management::cluster::bucket_conflict_resolution::unknown:
       bucket_settings.conflict_resolution_type =

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

@@ -192,6 +192,15 @@ options_to_origin(const std::string& connection_string, const couchbase::cluster
     user_options.tracing_options.eventing_threshold = opts.tracing.eventing_threshold;
   }
   user_options.transactions = opts.transactions;
+
+  user_options.enable_app_telemetry = opts.application_telemetry.enabled;
+  if (opts.application_telemetry.enabled) {
+    user_options.app_telemetry_endpoint = opts.application_telemetry.endpoint;
+    user_options.app_telemetry_ping_interval = opts.application_telemetry.ping_interval;
+    user_options.app_telemetry_ping_timeout = opts.application_telemetry.ping_timeout;
+    user_options.app_telemetry_backoff_interval = opts.application_telemetry.backoff_interval;
+  }
+
   // connection string might override some user options
   return { auth, core::utils::parse_connection_string(connection_string, user_options) };
 }

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

@@ -523,6 +523,7 @@ public:
           options.cas,
           options.access_deleted,
           options.create_as_deleted,
+          false,
           options.expiry,
           options.store_semantics,
           specs,
@@ -558,6 +559,7 @@ public:
       options.cas,
       options.access_deleted,
       options.create_as_deleted,
+      false,
       options.expiry,
       options.store_semantics,
       specs,

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

@@ -35,6 +35,7 @@
 #include "core/error_context/transaction_op_error_context.hxx"
 #include "core/impl/internal_error_context.hxx"
 #include "core/transactions/exceptions.hxx"
+#include "core/transactions/exceptions_fmt.hxx"
 #include "core/transactions/internal/exceptions_internal.hxx"
 
 #include <couchbase/error.hxx>

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

@@ -47,8 +47,59 @@ convert_log_level(couchbase::logger::log_level level) -> core::logger::level
   }
   return core::logger::level::off;
 }
+
+auto
+convert_log_level(core::logger::level level) -> couchbase::logger::log_level
+{
+  switch (level) {
+    case core::logger::level::trace:
+      return log_level::trace;
+    case core::logger::level::debug:
+      return log_level::debug;
+    case core::logger::level::info:
+      return log_level::info;
+    case core::logger::level::warn:
+      return log_level::warn;
+    case core::logger::level::err:
+      return log_level::error;
+    case core::logger::level::critical:
+      return log_level::critical;
+    case core::logger::level::off:
+    default:
+      break;
+  }
+  return log_level::off;
+}
+
+auto
+convert_log_location(const core::logger::log_location& location) -> couchbase::logger::log_location
+{
+  return couchbase::logger::log_location{ location.file, location.function, location.line };
+}
 } // namespace
 
+void
+register_log_callback(const log_callback& callback)
+{
+  if (callback == nullptr) {
+    return;
+  }
+
+  auto core_callback = [callback](const std::string_view msg,
+                                  const core::logger::level level,
+                                  const core::logger::log_location& location) {
+    callback(msg, convert_log_level(level), convert_log_location(location));
+  };
+
+  couchbase::core::logger::register_log_callback(std::move(core_callback));
+}
+
+void
+unregister_log_callback()
+{
+  couchbase::core::logger::unregister_log_callback();
+}
+
 void
 set_level(log_level level)
 {

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

@@ -29,7 +29,7 @@ effective_nodes(const document_id& id,
                 const read_preference& preference,
                 const std::string& preferred_server_group) -> std::vector<readable_node>
 {
-  if (preference != read_preference::no_preference && preferred_server_group.empty()) {
+  if (preference == read_preference::selected_server_group && preferred_server_group.empty()) {
     CB_LOG_WARNING("Preferred server group is required for zone-aware replica reads");
     return {};
   }

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

@@ -0,0 +1,32 @@
+/*
+ *     Copyright 2021-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.
+ */
+
+#include <couchbase/transactions/transaction_get_multi_replicas_from_preferred_server_group_spec.hxx>
+
+#include <couchbase/collection.hxx>
+
+namespace couchbase::transactions
+{
+transaction_get_multi_replicas_from_preferred_server_group_spec::
+  transaction_get_multi_replicas_from_preferred_server_group_spec(const collection& collection,
+                                                                  std::string id)
+  : bucket_{ collection.bucket_name() }
+  , scope_{ collection.scope_name() }
+  , collection_{ collection.name() }
+  , id_{ std::move(id) }
+{
+}
+} // namespace couchbase::transactions

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

@@ -0,0 +1,30 @@
+/*
+ *     Copyright 2021-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.
+ */
+
+#include <couchbase/transactions/transaction_get_multi_spec.hxx>
+
+#include <couchbase/collection.hxx>
+
+namespace couchbase::transactions
+{
+transaction_get_multi_spec::transaction_get_multi_spec(const collection& collection, std::string id)
+  : bucket_{ collection.bucket_name() }
+  , scope_{ collection.scope_name() }
+  , collection_{ collection.name() }
+  , id_{ std::move(id) }
+{
+}
+} // namespace couchbase::transactions

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

@@ -70,6 +70,8 @@ struct transaction_op_error_category : std::error_category {
         return "transaction_already_aborted (1318)";
       case errc::transaction_op::transaction_already_committed:
         return "transaction_already_committed (1319)";
+      case errc::transaction_op::document_unretrievable:
+        return "document_unretrievable (1320)";
       case errc::transaction_op::transaction_op_failed:
         return "transaction_op_failed (1399)";
     }

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

@@ -99,8 +99,8 @@ public:
   {
     io::mcbp_session new_session =
       origin_.options().enable_tls
-        ? io::mcbp_session(client_id_, ctx_, tls_, origin_, state_listener_)
-        : io::mcbp_session(client_id_, ctx_, origin_, state_listener_);
+        ? io::mcbp_session(client_id_, {}, ctx_, tls_, origin_, state_listener_)
+        : io::mcbp_session(client_id_, {}, ctx_, origin_, state_listener_);
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
     new_session.add_background_bootstrap_listener(shared_from_this());
 #endif
@@ -395,8 +395,8 @@ private:
         origin_.credentials(), hostname, port, origin_.options());
       io::mcbp_session session =
         origin_.options().enable_tls
-          ? io::mcbp_session(client_id_, ctx_, tls_, origin, state_listener_)
-          : io::mcbp_session(client_id_, ctx_, origin, state_listener_);
+          ? io::mcbp_session(client_id_, node.node_uuid, ctx_, tls_, origin, state_listener_)
+          : io::mcbp_session(client_id_, node.node_uuid, ctx_, origin, state_listener_);
       CB_LOG_DEBUG(R"({} rev={}, add cluster session="{}", address="{}:{}")",
                    log_prefix_,
                    config.rev_str(),
@@ -500,8 +500,8 @@ private:
         origin_.credentials(), hostname, port, origin_.options());
       io::mcbp_session session =
         origin_.options().enable_tls
-          ? io::mcbp_session(client_id_, ctx_, tls_, origin, state_listener_)
-          : io::mcbp_session(client_id_, ctx_, origin, state_listener_);
+          ? io::mcbp_session(client_id_, node.node_uuid, ctx_, tls_, origin, state_listener_)
+          : io::mcbp_session(client_id_, node.node_uuid, ctx_, origin, state_listener_);
       CB_LOG_DEBUG(R"({} rev={}, restart cluster session="{}", address="{}:{}")",
                    log_prefix_,
                    config_->rev_str(),

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

@@ -19,6 +19,7 @@
 
 #include <couchbase/build_config.hxx>
 
+#include "core/app_telemetry_meter.hxx"
 #include "core/impl/bootstrap_error.hxx"
 #include "core/metrics/meter_wrapper.hxx"
 #include "core/service_type_fmt.hxx"
@@ -52,6 +53,7 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
   std::shared_ptr<tracing::tracer_wrapper> tracer_;
   std::shared_ptr<couchbase::tracing::request_span> span_{ nullptr };
   std::shared_ptr<metrics::meter_wrapper> meter_{};
+  std::shared_ptr<core::app_telemetry_meter> app_telemetry_meter_{ nullptr };
   std::shared_ptr<io::http_session> session_{};
   http_command_handler handler_{};
   std::chrono::milliseconds timeout_{};
@@ -65,12 +67,14 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
                Request req,
                std::shared_ptr<tracing::tracer_wrapper> tracer,
                std::shared_ptr<metrics::meter_wrapper> meter,
+               std::shared_ptr<core::app_telemetry_meter> app_telemetry_meter,
                std::chrono::milliseconds default_timeout,
                std::chrono::milliseconds dispatch_timeout)
     : deadline(ctx)
     , request(req)
     , tracer_(std::move(tracer))
     , meter_(std::move(meter))
+    , app_telemetry_meter_(std::move(app_telemetry_meter))
     , timeout_(request.timeout.value_or(default_timeout))
     , client_context_id_(request.client_context_id.value_or(uuid::to_string(uuid::random())))
     , dispatch_timeout_(dispatch_timeout)
@@ -85,11 +89,13 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
                Request req,
                std::shared_ptr<tracing::tracer_wrapper> tracer,
                std::shared_ptr<metrics::meter_wrapper> meter,
+               std::shared_ptr<core::app_telemetry_meter> app_telemetry_meter,
                std::chrono::milliseconds default_timeout)
     : deadline(ctx)
     , request(req)
     , tracer_(std::move(tracer))
     , meter_(std::move(meter))
+    , app_telemetry_meter_(std::move(app_telemetry_meter))
     , timeout_(request.timeout.value_or(default_timeout))
     , client_context_id_(request.client_context_id.value_or(uuid::to_string(uuid::random())))
   {
@@ -128,12 +134,9 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
       if (ec == asio::error::operation_aborted) {
         return;
       }
-      CB_LOG_DEBUG(
-        R"(HTTP request timed out before dispatch: {}, method={}, path="{}", client_context_id="{}")",
-        self->encoded.type,
-        self->encoded.method,
-        self->encoded.path,
-        self->client_context_id_);
+      CB_LOG_DEBUG(R"(HTTP request timed out before dispatch: {}, client_context_id="{}")",
+                   self->request.type,
+                   self->client_context_id_);
       self->cancel(errc::common::unambiguous_timeout);
     });
 #endif
@@ -142,10 +145,8 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
       if (ec == asio::error::operation_aborted) {
         return;
       }
-      CB_LOG_DEBUG(R"(HTTP request timed out: {}, method={}, path="{}", client_context_id="{}")",
-                   self->encoded.type,
-                   self->encoded.method,
-                   self->encoded.path,
+      CB_LOG_DEBUG(R"(HTTP request timed out: {}, client_context_id="{}")",
+                   self->request.type,
                    self->client_context_id_);
       if constexpr (io::http_traits::supports_readonly_v<Request>) {
         if (self->request.readonly) {
@@ -176,6 +177,22 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
       span_ = nullptr;
     }
     if (auto handler = std::move(handler_); handler) {
+      const auto& node_uuid = session_ ? session_->node_uuid() : "";
+      auto telemetry_recorder = app_telemetry_meter_->value_recorder(node_uuid, {});
+      telemetry_recorder->update_counter(total_counter_for_service_type(request.type));
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+      std::error_code ec{};
+      if (std::holds_alternative<std::error_code>(error)) {
+        ec = std::get<std::error_code>(error);
+      } else if (std::holds_alternative<impl::bootstrap_error>(error)) {
+        ec = std::get<impl::bootstrap_error>(error).ec;
+      }
+#endif
+      if (ec == errc::common::ambiguous_timeout || ec == errc::common::unambiguous_timeout) {
+        telemetry_recorder->update_counter(timedout_counter_for_service_type(request.type));
+      } else if (ec == errc::common::request_canceled) {
+        telemetry_recorder->update_counter(canceled_counter_for_service_type(request.type));
+      }
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
       handler(error, std::move(msg));
     }
@@ -195,8 +212,9 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
     if (!handler_) {
       return;
     }
-    if (span_->uses_tags())
+    if (span_->uses_tags()) {
       span_->add_tag(tracing::attributes::local_id, session_->id());
+    }
     send();
   }
 
@@ -244,6 +262,12 @@ private:
         if (ec == asio::error::operation_aborted) {
           return self->invoke_handler(errc::common::ambiguous_timeout, std::move(msg));
         }
+
+        auto latency = std::chrono::duration_cast<std::chrono::milliseconds>(
+          std::chrono::steady_clock::now() - start);
+        self->app_telemetry_meter_->value_recorder(self->session_->node_uuid(), {})
+          ->record_latency(latency_for_service_type(self->request.type), latency);
+
         if (self->meter_) {
           metrics::metric_attributes attrs{
             self->request.type,

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

@@ -100,6 +100,7 @@ http_session_info::log_prefix() const -> const std::string&
 
 http_session::http_session(couchbase::core::service_type type,
                            std::string client_id,
+                           std::string node_uuid,
                            asio::io_context& ctx,
                            couchbase::core::cluster_credentials credentials,
                            std::string hostname,
@@ -107,6 +108,7 @@ http_session::http_session(couchbase::core::service_type type,
                            couchbase::core::http_context http_ctx)
   : type_(type)
   , client_id_(std::move(client_id))
+  , node_uuid_(std::move(node_uuid))
   , id_(uuid::to_string(uuid::random()))
   , ctx_(ctx)
   , resolver_(ctx_)
@@ -125,6 +127,7 @@ http_session::http_session(couchbase::core::service_type type,
 
 http_session::http_session(couchbase::core::service_type type,
                            std::string client_id,
+                           std::string node_uuid,
                            asio::io_context& ctx,
                            asio::ssl::context& tls,
                            couchbase::core::cluster_credentials credentials,
@@ -133,6 +136,7 @@ http_session::http_session(couchbase::core::service_type type,
                            couchbase::core::http_context http_ctx)
   : type_(type)
   , client_id_(std::move(client_id))
+  , node_uuid_(std::move(node_uuid))
   , id_(uuid::to_string(uuid::random()))
   , ctx_(ctx)
   , resolver_(ctx_)
@@ -207,6 +211,12 @@ http_session::id() const -> const std::string&
   return id_;
 }
 
+auto
+http_session::node_uuid() const -> const std::string&
+{
+  return node_uuid_;
+}
+
 auto
 http_session::credentials() const -> const cluster_credentials&
 {

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

@@ -71,6 +71,7 @@ class http_session : public std::enable_shared_from_this<http_session>
 public:
   http_session(service_type type,
                std::string client_id,
+               std::string node_uuid,
                asio::io_context& ctx,
                cluster_credentials credentials,
                std::string hostname,
@@ -79,6 +80,7 @@ public:
 
   http_session(service_type type,
                std::string client_id,
+               std::string node_uuid,
                asio::io_context& ctx,
                asio::ssl::context& tls,
                cluster_credentials credentials,
@@ -95,6 +97,7 @@ public:
   [[nodiscard]] auto diag_info() -> diag::endpoint_diag_info;
   [[nodiscard]] auto log_prefix() -> std::string;
   [[nodiscard]] auto id() const -> const std::string&;
+  [[nodiscard]] auto node_uuid() const -> const std::string&;
   [[nodiscard]] auto credentials() const -> const cluster_credentials&;
   [[nodiscard]] auto is_connected() const -> bool;
   [[nodiscard]] auto type() const -> service_type;
@@ -196,6 +199,7 @@ private:
 
   service_type type_{};
   std::string client_id_;
+  std::string node_uuid_;
   std::string id_;
   asio::io_context& ctx_;
   asio::ip::tcp::resolver resolver_;