couchbase 3.7.0 → 3.8.1

data/ext/couchbase/core/cluster.hxx

@@ -17,7 +17,9 @@
 
 #pragma once
 
+#include "deprecation_utils.hxx"
 #include "diagnostics.hxx"
+#include "error.hxx"
 #include "operations_fwd.hxx"
 #include "origin.hxx"
 #include "topology/configuration.hxx"
@@ -37,6 +39,17 @@ namespace couchbase::core
 {
 class crud_component;
 class cluster_impl;
+class cluster_label_listener;
+
+namespace tracing
+{
+class tracer_wrapper;
+} // namespace tracing
+
+namespace metrics
+{
+class meter_wrapper;
+} // namespace metrics
 
 namespace mcbp
 {
@@ -80,6 +93,8 @@ public:
     utils::movable_function<void(std::error_code, std::shared_ptr<topology::configuration>)>&&
       handler) const;
 
+  [[nodiscard]] auto update_credentials(const core::cluster_credentials& auth) const -> core::error;
+
   void execute(o::analytics_request request, mf<void(o::analytics_response)>&& handler) const;
   void execute(o::append_request request, mf<void(o::append_response)>&& handler) const;
   void execute(o::decrement_request request, mf<void(o::decrement_response)>&& handler) const;
@@ -129,6 +144,10 @@ public:
   void execute(o::replace_request_with_legacy_durability request,
                mf<void(o::replace_response)>&& handler) const;
 
+  COUCHBASE_DEPRECATED(
+    "1.3.0",
+    "Views are deprecated in Couchbase Server 7.0+. Instead of views, use the Query "
+    "Service (SQL++).")
   void execute(o::document_view_request request,
                mf<void(o::document_view_response)>&& handler) const;
   void execute(o::http_noop_request request, mf<void(o::http_noop_response)>&& handler) const;
@@ -273,6 +292,14 @@ public:
   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;
+  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;
+  void execute(o::lookup_in_replica_request_with_cancellation request,
+               mf<void(impl::lookup_in_replica_response)>&& handler) const;
+
   void execute(
     om::analytics_link_replace_request<management::analytics::azure_blob_external_link> request,
     mf<void(om::analytics_link_replace_response)>&& handler) const;
@@ -312,6 +339,11 @@ 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 cluster_label_listener() const
+    -> const std::shared_ptr<cluster_label_listener>&;
+
 private:
   std::shared_ptr<cluster_impl> impl_;
 };

data/ext/couchbase/core/cluster_credentials.cxx

@@ -24,4 +24,29 @@ cluster_credentials::uses_certificate() const -> bool
 {
   return !certificate_path.empty();
 }
+
+auto
+cluster_credentials::requires_tls() const -> bool
+{
+  return uses_certificate() || uses_jwt();
+}
+
+auto
+cluster_credentials::uses_jwt() const -> bool
+{
+  return !jwt_token.empty();
+}
+
+auto
+cluster_credentials::uses_password() const -> bool
+{
+  return !username.empty() && !password.empty();
+}
+
+auto
+cluster_credentials::is_same_type(const cluster_credentials& other) const -> bool
+{
+  return uses_certificate() == other.uses_certificate() && uses_jwt() == other.uses_jwt() &&
+         uses_password() == other.uses_password();
+}
 } // namespace couchbase::core

data/ext/couchbase/core/cluster_credentials.hxx

@@ -28,9 +28,14 @@ struct cluster_credentials {
   std::string password{};
   std::string certificate_path{};
   std::string key_path{};
+  std::string jwt_token{};
   std::optional<std::vector<std::string>> allowed_sasl_mechanisms{};
 
   [[nodiscard]] auto uses_certificate() const -> bool;
+  [[nodiscard]] auto requires_tls() const -> bool;
+  [[nodiscard]] auto uses_jwt() const -> bool;
+  [[nodiscard]] auto uses_password() const -> bool;
+  [[nodiscard]] auto is_same_type(const cluster_credentials& other) const -> bool;
 };
 
 } // namespace couchbase::core

data/ext/couchbase/core/cluster_label_listener.cxx

@@ -0,0 +1,72 @@
+/* -*- 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.
+ */
+
+#include "cluster_label_listener.hxx"
+
+#include <mutex>
+#include <shared_mutex>
+
+namespace couchbase::core
+{
+class cluster_label_listener_impl
+{
+public:
+  cluster_label_listener_impl() = default;
+
+  void update_config(topology::configuration config)
+  {
+    const std::scoped_lock lock(mutex_);
+    if (config.cluster_name.has_value() && (cluster_name_ != config.cluster_name)) {
+      cluster_name_ = std::move(config.cluster_name);
+    }
+    if (config.cluster_uuid.has_value() && (cluster_uuid_ != config.cluster_uuid)) {
+      cluster_uuid_ = std::move(config.cluster_uuid);
+    }
+  }
+
+  auto cluster_labels() -> cluster_label_listener::labels
+  {
+    const std::shared_lock lock(mutex_);
+    return cluster_label_listener::labels{
+      cluster_name_,
+      cluster_uuid_,
+    };
+  }
+
+private:
+  std::shared_mutex mutex_{};
+  std::optional<std::string> cluster_name_{};
+  std::optional<std::string> cluster_uuid_{};
+};
+
+cluster_label_listener::cluster_label_listener()
+  : impl_{ std::make_shared<cluster_label_listener_impl>() }
+{
+}
+
+void
+cluster_label_listener::update_config(topology::configuration config)
+{
+  impl_->update_config(std::move(config));
+}
+
+auto
+cluster_label_listener::cluster_labels() const -> labels
+{
+  return impl_->cluster_labels();
+}
+} // namespace couchbase::core

data/ext/couchbase/core/cluster_label_listener.hxx

@@ -0,0 +1,46 @@
+/* -*- 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
+
+#include "config_listener.hxx"
+
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace couchbase::core
+{
+class cluster_label_listener_impl;
+
+class cluster_label_listener : public config_listener
+{
+public:
+  cluster_label_listener();
+  void update_config(topology::configuration config) override;
+
+  struct labels {
+    std::optional<std::string> cluster_name;
+    std::optional<std::string> cluster_uuid;
+  };
+
+  [[nodiscard]] auto cluster_labels() const -> labels;
+
+private:
+  std::shared_ptr<cluster_label_listener_impl> impl_;
+};
+} // namespace couchbase::core

data/ext/couchbase/core/cluster_options.hxx

@@ -21,6 +21,7 @@
 #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/tracing/threshold_logging_options.hxx"
 #include "service_type.hxx"
 #include "timeout_defaults.hxx"
@@ -72,9 +73,11 @@ public:
   bool enable_compression{ true };
   bool enable_tracing{ true };
   bool enable_metrics{ true };
+  bool enable_orphan_reporting{ true };
   std::string network{ "auto" };
   tracing::threshold_logging_options tracing_options{};
   metrics::logging_meter_options metrics_options{};
+  orphan_reporter_options orphan_options{};
   tls_verify_mode tls_verify{ tls_verify_mode::peer };
   std::shared_ptr<couchbase::tracing::request_tracer> tracer{ nullptr };
   std::shared_ptr<couchbase::metrics::meter> meter{ nullptr };
@@ -110,6 +113,7 @@ public:
   };
   bool preserve_bootstrap_nodes_order{ false };
   bool allow_enterprise_analytics{ false };
+  bool enable_lazy_connections{ false };
 };
 
 } // namespace couchbase::core

data/ext/couchbase/core/deprecation_utils.hxx

@@ -0,0 +1,26 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-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
+
+#ifndef COUCHBASE_DEPRECATED
+#ifdef COUCHBASE_CXX_CLIENT_IGNORE_CORE_DEPRECATIONS
+#define COUCHBASE_DEPRECATED(version, msg)
+#else
+#define COUCHBASE_DEPRECATED(version, msg) [[deprecated("Since SDK " version ". " msg)]]
+#endif
+#endif

data/ext/couchbase/core/error.hxx

@@ -0,0 +1,27 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ * Copyright 2022-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
+ *
+ *     https://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
+
+#include <string>
+#include <system_error>
+
+namespace couchbase::core
+{
+struct error {
+  std::error_code ec;
+  std::string message;
+};
+} // namespace couchbase::core

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

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include <couchbase/node_id.hxx>
 #include <couchbase/retry_reason.hxx>
 
 #include <cstdint>
@@ -74,6 +75,23 @@ public:
   {
   }
 
+  base_error_context(std::string operation_id,
+                     std::error_code ec,
+                     std::optional<std::string> last_dispatched_to,
+                     std::optional<std::string> last_dispatched_from,
+                     std::size_t retry_attempts,
+                     std::set<retry_reason> retry_reasons,
+                     couchbase::node_id last_dispatched_to_node_id)
+    : 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) }
+    , last_dispatched_to_node_id_{ std::move(last_dispatched_to_node_id) }
+  {
+  }
+
   [[nodiscard]] virtual auto operation_id() const -> const std::string&
   {
     return operation_id_;
@@ -173,6 +191,19 @@ public:
     return retry_reasons_.count(reason) > 0;
   }
 
+  /**
+   * Identity of the cluster node that last handled this request.
+   *
+   * @return node_id (default-constructed / falsy when unknown)
+   *
+   * @since 1.3.2
+   * @uncommitted
+   */
+  [[nodiscard]] virtual auto last_dispatched_to_node_id() const -> const couchbase::node_id&
+  {
+    return last_dispatched_to_node_id_;
+  }
+
 private:
   std::string operation_id_{};
   std::error_code ec_{};
@@ -180,5 +211,6 @@ private:
   std::optional<std::string> last_dispatched_from_{};
   std::size_t retry_attempts_{ 0 };
   std::set<retry_reason> retry_reasons_{};
+  couchbase::node_id last_dispatched_to_node_id_{};
 };
 } // namespace couchbase::core

data/ext/couchbase/core/error_context/key_value.cxx

@@ -51,6 +51,7 @@ make_subdocument_error_context(const key_value_error_context& ctx,
     ctx.last_dispatched_from(),
     ctx.retry_attempts(),
     ctx.retry_reasons(),
+    ctx.last_dispatched_to_node_id(),
     ctx.id(),
     ctx.bucket(),
     ctx.scope(),

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

@@ -20,6 +20,7 @@
 #include "subdocument_error_context.hxx"
 
 #include "core/document_id.hxx"
+#include "core/impl/node_id.hxx"
 #include "key_value_error_context.hxx"
 
 #include <optional>
@@ -57,12 +58,34 @@ make_key_value_error_context(std::error_code ec,
   auto retry_attempts = command->request.retries.retry_attempts();
   auto retry_reasons = command->request.retries.retry_reasons();
 
+  // Build node_id from the session that handled this request.
+  // The session carries the node_uuid (empty on pre-8.0 servers),
+  // canonical hostname, and port — we use these to construct the
+  // fallback identifier when nodeUUID is unavailable.
+  //
+  // Only construct a node_id once the session has actually been bound to a
+  // concrete node: either a non-empty UUID, or a non-empty canonical
+  // hostname *and* a non-zero canonical KV port. Otherwise the fallback
+  // hash of ("", "", 0) would yield a truthy-but-meaningless node_id and
+  // break the contract that a default-constructed node_id means "unknown".
+  couchbase::node_id dispatched_to_node_id{};
+  if (command->session_) {
+    const auto& node_uuid = command->session_->node_uuid();
+    const auto& canonical_hostname = command->session_->canonical_hostname();
+    const auto canonical_port = command->session_->canonical_port_number();
+    if (!node_uuid.empty() || (!canonical_hostname.empty() && canonical_port != 0)) {
+      dispatched_to_node_id =
+        internal_node_id::build(node_uuid, canonical_hostname, canonical_port);
+    }
+  }
+
   return { command->id_,
            ec,
            command->last_dispatched_to_,
            command->last_dispatched_from_,
            retry_attempts,
            std::move(retry_reasons),
+           std::move(dispatched_to_node_id),
            key,
            bucket,
            scope,

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

@@ -101,6 +101,41 @@ public:
   {
   }
 
+  key_value_error_context(std::string operation_id,
+                          std::error_code ec,
+                          std::optional<std::string> last_dispatched_to,
+                          std::optional<std::string> last_dispatched_from,
+                          std::size_t retry_attempts,
+                          std::set<retry_reason> retry_reasons,
+                          couchbase::node_id dispatched_to_node_id,
+                          std::string id,
+                          std::string bucket,
+                          std::string scope,
+                          std::string collection,
+                          std::uint32_t opaque,
+                          std::optional<key_value_status_code> status_code,
+                          couchbase::cas cas,
+                          std::optional<key_value_error_map_info> error_map_info,
+                          std::optional<key_value_extended_error_info> extended_error_info)
+    : base_error_context{ std::move(operation_id),
+                          ec,
+                          std::move(last_dispatched_to),
+                          std::move(last_dispatched_from),
+                          retry_attempts,
+                          std::move(retry_reasons),
+                          std::move(dispatched_to_node_id) }
+    , id_{ std::move(id) }
+    , bucket_{ std::move(bucket) }
+    , scope_{ std::move(scope) }
+    , collection_{ std::move(collection) }
+    , opaque_{ opaque }
+    , status_code_{ status_code }
+    , cas_{ cas }
+    , error_map_info_{ std::move(error_map_info) }
+    , extended_error_info_{ std::move(extended_error_info) }
+  {
+  }
+
   /**
    * Returns identifier (key) of the document referenced in the operation.
    *

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

@@ -102,6 +102,47 @@ public:
   {
   }
 
+  subdocument_error_context(std::string operation_id,
+                            std::error_code ec,
+                            std::optional<std::string> last_dispatched_to,
+                            std::optional<std::string> last_dispatched_from,
+                            std::size_t retry_attempts,
+                            std::set<retry_reason> retry_reasons,
+                            couchbase::node_id dispatched_to_node_id,
+                            std::string id,
+                            std::string bucket,
+                            std::string scope,
+                            std::string collection,
+                            std::uint32_t opaque,
+                            std::optional<key_value_status_code> status_code,
+                            couchbase::cas cas,
+                            std::optional<key_value_error_map_info> error_map_info,
+                            std::optional<key_value_extended_error_info> extended_error_info,
+                            std::optional<std::string> first_error_path,
+                            std::optional<std::uint64_t> first_error_index,
+                            bool deleted)
+    : key_value_error_context{ std::move(operation_id),
+                               ec,
+                               std::move(last_dispatched_to),
+                               std::move(last_dispatched_from),
+                               retry_attempts,
+                               std::move(retry_reasons),
+                               std::move(dispatched_to_node_id),
+                               std::move(id),
+                               std::move(bucket),
+                               std::move(scope),
+                               std::move(collection),
+                               opaque,
+                               status_code,
+                               cas,
+                               std::move(error_map_info),
+                               std::move(extended_error_info) }
+    , first_error_path_{ std::move(first_error_path) }
+    , first_error_index_{ first_error_index }
+    , deleted_{ deleted }
+  {
+  }
+
   /**
    * Returns path of the operation that generated first error
    *

data/ext/couchbase/core/free_form_http_request.hxx

@@ -48,8 +48,6 @@ public:
   std::string method{};
   std::string endpoint{};
   std::string path{};
-  std::string username{};
-  std::string password{};
   std::string body{};
   std::map<std::string, std::string> headers{};
   std::string content_type{};