couchbase 3.7.0 → 3.8.0

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

@@ -19,8 +19,10 @@
 
 #include <couchbase/build_config.hxx>
 
+#include "core/cluster_credentials.hxx"
 #include "core/protocol/hello_feature.hxx"
 #include "core/response_handler.hxx"
+#include "core/tls_context_provider.hxx"
 #include "core/utils/movable_function.hxx"
 #include "mcbp_context.hxx"
 #include "mcbp_message.hxx"
@@ -100,7 +102,7 @@ public:
   mcbp_session(const std::string& client_id,
                const std::string& node_uuid,
                asio::io_context& ctx,
-               asio::ssl::context& tls,
+               tls_context_provider& tls,
                couchbase::core::origin origin,
                std::shared_ptr<impl::bootstrap_state_listener> state_listener,
                std::optional<std::string> bucket_name = {},
@@ -119,6 +121,8 @@ public:
   [[nodiscard]] auto id() const -> const std::string&;
   [[nodiscard]] auto node_uuid() const -> const std::string&;
   [[nodiscard]] auto remote_address() const -> std::string;
+  [[nodiscard]] auto remote_hostname() const -> std::string;
+  [[nodiscard]] auto remote_port() const -> std::uint16_t;
   [[nodiscard]] auto local_address() const -> std::string;
   [[nodiscard]] auto bootstrap_address() const -> const std::string&;
   [[nodiscard]] auto bootstrap_hostname() const -> const std::string&;
@@ -126,6 +130,8 @@ public:
   [[nodiscard]] auto bootstrap_port_number() const -> std::uint16_t;
   [[nodiscard]] auto last_bootstrap_error() && -> std::optional<impl::bootstrap_error>;
   [[nodiscard]] auto last_bootstrap_error() const& -> const std::optional<impl::bootstrap_error>&;
+  [[nodiscard]] auto canonical_hostname() const -> const std::string&;
+  [[nodiscard]] auto canonical_port_number() const -> std::uint16_t;
   void write_and_flush(std::vector<std::byte>&& buffer);
   void write_and_subscribe(const std::shared_ptr<mcbp::queue_request>&,
                            const std::shared_ptr<response_handler>& handler);
@@ -134,6 +140,8 @@ public:
                            command_handler&& handler);
   void bootstrap(utils::movable_function<void(std::error_code, topology::configuration)>&& handler,
                  bool retry_on_bucket_not_found = false);
+  void reauthenticate();
+  void update_credentials(cluster_credentials credentials);
   void on_stop(utils::movable_function<void()> handler);
   void stop(retry_reason reason);
   [[nodiscard]] auto index() const -> std::size_t;

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

@@ -27,12 +27,4 @@ struct supports_durability : public std::false_type {
 
 template<typename T>
 inline constexpr bool supports_durability_v = supports_durability<T>::value;
-
-template<typename T>
-struct supports_parent_span : public std::false_type {
-};
-
-template<typename T>
-inline constexpr bool supports_parent_span_v = supports_parent_span<T>::value;
-
 } // namespace couchbase::core::io::mcbp_traits

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

@@ -140,12 +140,12 @@ plain_stream_impl::async_read_some(
   return stream_->async_read_some(buffer, std::move(handler));
 }
 
-tls_stream_impl::tls_stream_impl(asio::io_context& ctx, asio::ssl::context& tls)
+tls_stream_impl::tls_stream_impl(asio::io_context& ctx, tls_context_provider& tls)
   : stream_impl(ctx, true)
   , tls_(tls)
   , stream_(
       std::make_shared<asio::ssl::stream<asio::ip::tcp::socket>>(asio::ip::tcp::socket(strand_),
-                                                                 tls_))
+                                                                 *tls_.get_ctx()))
 {
 }
 
@@ -204,7 +204,7 @@ tls_stream_impl::async_connect(const asio::ip::tcp::resolver::results_type::endp
   if (!stream_) {
     id_ = uuid::to_string(uuid::random());
     stream_ = std::make_shared<asio::ssl::stream<asio::ip::tcp::socket>>(
-      asio::ip::tcp::socket(strand_), tls_);
+      asio::ip::tcp::socket(strand_), *tls_.get_ctx());
   }
   return stream_->lowest_layer().async_connect(
     endpoint, [stream = stream_, handler = std::move(handler)](std::error_code ec_connect) mutable {

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

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include "core/tls_context_provider.hxx"
 #include "core/utils/movable_function.hxx"
 #include "ip_protocol.hxx"
 
@@ -129,11 +130,11 @@ public:
 class tls_stream_impl : public stream_impl
 {
 private:
-  asio::ssl::context& tls_;
+  tls_context_provider& tls_;
   std::shared_ptr<asio::ssl::stream<asio::ip::tcp::socket>> stream_;
 
 public:
-  tls_stream_impl(asio::io_context& ctx, asio::ssl::context& tls);
+  tls_stream_impl(asio::io_context& ctx, tls_context_provider& tls);
 
   [[nodiscard]] auto local_endpoint() const -> asio::ip::tcp::endpoint override;
 

data/ext/couchbase/core/meta/features.hxx

@@ -253,3 +253,18 @@
  * couchbase::vector_query has a prefilter option.
  */
 #define COUCHBASE_CXX_CLIENT_HAS_VECTOR_SEARCH_PREFILTER 1
+
+/**
+ * couchbase::cluster has set_authenticator() method.
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_SET_AUTHENTICATOR 1
+
+/**
+ * Support for the jwt_authenticator
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_JWT_AUTHENTICATOR 1
+
+/**
+ * Support for the stable OpenTelemetry conventions (Observability RFC revisions 26 & 27)
+ */
+#define COUCHBASE_CXX_CLIENT_STABLE_OTEL_CONVENTIONS 1

data/ext/couchbase/core/meta/version.cxx

@@ -34,6 +34,9 @@
 #include <snappy-stubs-public.h>
 #include <spdlog/fmt/bundled/core.h>
 #include <spdlog/version.h>
+#ifdef COUCHBASE_CXX_CLIENT_BUILD_OPENTELEMETRY
+#include <opentelemetry/version.h>
+#endif
 
 #include <regex>
 
@@ -168,10 +171,20 @@ sdk_build_info() -> std::map<std::string, std::string>
 #if defined(__GLIBC__)
   info["libc"] = fmt::format("glibc {}.{}", __GLIBC__, __GLIBC_MINOR__);
 #endif
+#ifdef COUCHBASE_CXX_CLIENT_BUILD_OPENTELEMETRY
+  info["opentelemetry"] = OPENTELEMETRY_VERSION;
+  info["opentelemetry_abi"] = OPENTELEMETRY_ABI_VERSION;
+#endif
 
   return info;
 }
 
+auto
+is_debug() -> bool
+{
+  return COUCHBASE_CXX_CLIENT_DEBUG_BUILD;
+}
+
 auto
 sdk_build_info_json() -> std::string
 {

data/ext/couchbase/core/meta/version.hxx

@@ -64,4 +64,7 @@ user_agent_for_mcbp(const std::string& client_id,
                     const std::string& session_id,
                     const std::string& extra = "",
                     std::size_t max_length = 0) -> std::string;
+
+auto
+is_debug() -> bool;
 } // namespace couchbase::core::meta

data/ext/couchbase/core/metrics/constants.hxx

@@ -0,0 +1,23 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2025-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.
+ */
+
+#pragma once
+
+namespace couchbase::core::metrics
+{
+constexpr auto operation_meter_name = "db.client.operation.duration";
+} // namespace couchbase::core::metrics

data/ext/couchbase/core/metrics/logging_meter.cxx

@@ -19,7 +19,9 @@
 
 #include "couchbase/build_info.hxx"
 
+#include "constants.hxx"
 #include "core/logger/logger.hxx"
+#include "core/tracing/constants.hxx"
 #include "core/utils/json.hxx"
 #include "noop_meter.hxx"
 
@@ -209,18 +211,16 @@ logging_meter::get_value_recorder(const std::string& name,
     std::make_shared<noop_value_recorder>()
   };
 
-  if (static const std::string meter_name = "db.couchbase.operations"; name != meter_name) {
+  if (name != operation_meter_name) {
     return noop_recorder;
   }
 
-  static const std::string service_tag = "db.couchbase.service";
-  const auto service = tags.find(service_tag);
+  const auto service = tags.find(tracing::attributes::op::service);
   if (service == tags.end()) {
     return noop_recorder;
   }
 
-  static const std::string operation_tag = "db.operation";
-  const auto operation = tags.find(operation_tag);
+  const auto operation = tags.find(tracing::attributes::op::operation_name);
   if (operation == tags.end()) {
     return noop_recorder;
   }

data/ext/couchbase/core/metrics/meter_wrapper.cxx

@@ -19,8 +19,14 @@
 
 #include <couchbase/error_codes.hxx>
 
-#include <mutex>
+#include "core/metrics/constants.hxx"
+#include "core/tracing/constants.hxx"
+
+#include <map>
+#include <memory>
+#include <string>
 #include <system_error>
+#include <utility>
 
 namespace couchbase::core::metrics
 {
@@ -57,32 +63,10 @@ extract_error_name(std::error_code ec) -> std::string
 }
 
 auto
-service_to_string(service_type s) -> std::string
-{
-  switch (s) {
-    case service_type::analytics:
-      return "analytics";
-    case service_type::search:
-      return "search";
-    case service_type::key_value:
-      return "kv";
-    case service_type::management:
-      return "management";
-    case service_type::eventing:
-      return "eventing";
-    case service_type::query:
-      return "query";
-    case service_type::view:
-      return "views";
-  }
-  return {};
-}
-
-auto
-get_standardized_outcome(std::error_code ec) -> std::string
+get_standardized_error_type(std::error_code ec) -> std::string
 {
   if (!ec) {
-    return "Success";
+    return {};
   }
 
   // SDK-specific errors
@@ -95,39 +79,62 @@ get_standardized_outcome(std::error_code ec) -> std::string
     return "CryptoError";
   }
 
-  return snake_case_to_camel_case(extract_error_name(ec));
+  static const std::array<const std::error_category*, 12> cb_categories = {
+    &impl::common_category(),      &impl::key_value_category(),
+    &impl::query_category(),       &impl::analytics_category(),
+    &impl::search_category(),      &impl::view_category(),
+    &impl::management_category(),  &impl::field_level_encryption_category(),
+    &impl::network_category(),     &impl::streaming_json_lexer_category(),
+    &impl::transaction_category(), &impl::transaction_op_category(),
+  };
+
+  if (std::any_of(
+        cb_categories.begin(), cb_categories.end(), [&ec](const std::error_category* cat) -> bool {
+          return &ec.category() == cat;
+        })) {
+    return snake_case_to_camel_case(extract_error_name(ec));
+  }
+
+  return "_OTHER";
 }
 } // namespace
 
 auto
 metric_attributes::encode() const -> std::map<std::string, std::string>
 {
-  std::map<std::string, std::string> tags = { { "db.couchbase.service",
-                                                service_to_string(service) },
-                                              { "db.operation", operation },
-                                              { "outcome", get_standardized_outcome(ec) } };
+  std::map<std::string, std::string> tags = {
+    { tracing::attributes::reserved::target_unit, "s" },
+    { tracing::attributes::common::system, "couchbase" },
+    { tracing::attributes::op::service, service },
+    { tracing::attributes::op::operation_name, operation },
+  };
 
   if (internal.cluster_name.has_value()) {
-    tags.emplace("db.couchbase.cluster_name", internal.cluster_name.value());
+    tags.emplace(tracing::attributes::common::cluster_name, internal.cluster_name.value());
   }
   if (internal.cluster_uuid.has_value()) {
-    tags.emplace("db.couchbase.cluster_uuid", internal.cluster_uuid.value());
+    tags.emplace(tracing::attributes::common::cluster_uuid, internal.cluster_uuid.value());
   }
   if (bucket_name) {
-    tags.emplace("db.name", bucket_name.value());
+    tags.emplace(tracing::attributes::op::bucket_name, bucket_name.value());
   }
   if (scope_name) {
-    tags.emplace("db.couchbase.scope", scope_name.value());
+    tags.emplace(tracing::attributes::op::scope_name, scope_name.value());
   }
   if (collection_name) {
-    tags.emplace("db.couchbase.collection", collection_name.value());
+    tags.emplace(tracing::attributes::op::collection_name, collection_name.value());
+  }
+  if (ec) {
+    tags.emplace(tracing::attributes::op::error_type, get_standardized_error_type(ec));
   }
 
   return tags;
 }
 
-meter_wrapper::meter_wrapper(std::shared_ptr<couchbase::metrics::meter> meter)
+meter_wrapper::meter_wrapper(std::shared_ptr<couchbase::metrics::meter> meter,
+                             std::shared_ptr<cluster_label_listener> label_listener)
   : meter_{ std::move(meter) }
+  , cluster_label_listener_{ std::move(label_listener) }
 {
 }
 
@@ -143,46 +150,41 @@ meter_wrapper::stop()
   meter_->stop();
 }
 
+void
+meter_wrapper::record_value(const std::map<std::string, std::string>& raw_attrs,
+                            std::chrono::microseconds duration)
+{
+  meter_->get_value_recorder(operation_meter_name, raw_attrs)->record_value(duration.count());
+}
+
 void
 meter_wrapper::record_value(metric_attributes attrs,
                             std::chrono::steady_clock::time_point start_time)
 {
-  static const std::string meter_name{ "db.couchbase.operations" };
-
-  {
-    const std::shared_lock lock{ cluster_labels_mutex_ };
-
-    if (cluster_name_) {
-      attrs.internal.cluster_name = cluster_name_;
-    }
-    if (cluster_uuid_) {
-      attrs.internal.cluster_uuid = cluster_uuid_;
-    }
+  auto [cluster_name, cluster_uuid] = cluster_label_listener_->cluster_labels();
+  if (cluster_name) {
+    attrs.internal.cluster_name = cluster_name;
+  }
+  if (cluster_uuid) {
+    attrs.internal.cluster_uuid = cluster_uuid;
   }
 
-  auto tags = attrs.encode();
-  meter_->get_value_recorder(meter_name, tags)
-    ->record_value(std::chrono::duration_cast<std::chrono::microseconds>(
-                     std::chrono::steady_clock::now() - start_time)
-                     .count());
+  record_value(attrs.encode(),
+               std::chrono::duration_cast<std::chrono::microseconds>(
+                 std::chrono::steady_clock::now() - start_time));
 }
 
-void
-meter_wrapper::update_config(topology::configuration config)
+auto
+meter_wrapper::wrapped() -> std::shared_ptr<couchbase::metrics::meter>
 {
-  const std::scoped_lock<std::shared_mutex> lock{ cluster_labels_mutex_ };
-  if (config.cluster_uuid.has_value()) {
-    cluster_uuid_ = config.cluster_uuid;
-  }
-  if (config.cluster_name.has_value()) {
-    cluster_name_ = config.cluster_name;
-  }
+  return meter_;
 }
 
 auto
-meter_wrapper::create(std::shared_ptr<couchbase::metrics::meter> meter)
+meter_wrapper::create(std::shared_ptr<couchbase::metrics::meter> meter,
+                      std::shared_ptr<cluster_label_listener> label_listener)
   -> std::shared_ptr<meter_wrapper>
 {
-  return std::make_shared<meter_wrapper>(std::move(meter));
+  return std::make_shared<meter_wrapper>(std::move(meter), std::move(label_listener));
 }
 } // namespace couchbase::core::metrics

data/ext/couchbase/core/metrics/meter_wrapper.hxx

@@ -26,14 +26,15 @@
 #include <chrono>
 #include <map>
 #include <optional>
-#include <shared_mutex>
 #include <string>
 #include <system_error>
 
+#include "core/cluster_label_listener.hxx"
+
 namespace couchbase::core::metrics
 {
 struct metric_attributes {
-  couchbase::core::service_type service;
+  std::string service;
   std::string operation;
   std::error_code ec;
   std::optional<std::string> bucket_name{};
@@ -48,26 +49,27 @@ struct metric_attributes {
   [[nodiscard]] auto encode() const -> std::map<std::string, std::string>;
 };
 
-class meter_wrapper : public config_listener
+class meter_wrapper
 {
 public:
-  explicit meter_wrapper(std::shared_ptr<couchbase::metrics::meter> meter);
+  explicit meter_wrapper(std::shared_ptr<couchbase::metrics::meter> meter,
+                         std::shared_ptr<cluster_label_listener> label_listener);
 
   void start();
   void stop();
 
   void record_value(metric_attributes attrs, std::chrono::steady_clock::time_point start_time);
+  void record_value(const std::map<std::string, std::string>& raw_attrs,
+                    std::chrono::microseconds duration);
 
-  void update_config(topology::configuration config) override;
+  [[nodiscard]] auto wrapped() -> std::shared_ptr<couchbase::metrics::meter>;
 
-  [[nodiscard]] static auto create(std::shared_ptr<couchbase::metrics::meter> meter)
+  [[nodiscard]] static auto create(std::shared_ptr<couchbase::metrics::meter> meter,
+                                   std::shared_ptr<cluster_label_listener> label_listener)
     -> std::shared_ptr<meter_wrapper>;
 
 private:
   std::shared_ptr<couchbase::metrics::meter> meter_;
-
-  std::optional<std::string> cluster_name_{};
-  std::optional<std::string> cluster_uuid_{};
-  std::shared_mutex cluster_labels_mutex_{};
+  std::shared_ptr<cluster_label_listener> cluster_label_listener_;
 };
 } // namespace couchbase::core::metrics

data/ext/couchbase/core/operations/document_analytics.hxx

@@ -114,11 +114,6 @@ struct analytics_request {
 } // namespace couchbase::core::operations
 namespace couchbase::core::io::http_traits
 {
-template<>
-struct supports_parent_span<couchbase::core::operations::analytics_request>
-  : public std::true_type {
-};
-
 template<>
 struct supports_readonly<couchbase::core::operations::analytics_request> : public std::true_type {
 };

data/ext/couchbase/core/operations/document_append.hxx

@@ -76,8 +76,4 @@ namespace couchbase::core::io::mcbp_traits
 template<>
 struct supports_durability<couchbase::core::operations::append_request> : public std::true_type {
 };
-
-template<>
-struct supports_parent_span<couchbase::core::operations::append_request> : public std::true_type {
-};
 } // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_decrement.hxx

@@ -79,9 +79,4 @@ namespace couchbase::core::io::mcbp_traits
 template<>
 struct supports_durability<couchbase::core::operations::decrement_request> : public std::true_type {
 };
-
-template<>
-struct supports_parent_span<couchbase::core::operations::decrement_request>
-  : public std::true_type {
-};
 } // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_exists.hxx

@@ -67,10 +67,3 @@ struct exists_request {
 };
 
 } // namespace couchbase::core::operations
-
-namespace couchbase::core::io::mcbp_traits
-{
-template<>
-struct supports_parent_span<couchbase::core::operations::exists_request> : public std::true_type {
-};
-} // namespace couchbase::core::io::mcbp_traits

data/ext/couchbase/core/operations/document_get.hxx

@@ -57,10 +57,3 @@ struct get_request {
                                    const encoded_response_type& encoded) const -> get_response;
 };
 } // namespace couchbase::core::operations
-
-namespace couchbase::core::io::mcbp_traits
-{
-template<>
-struct supports_parent_span<couchbase::core::operations::get_request> : public std::true_type {
-};
-} // namespace couchbase::core::io::mcbp_traits