couchbase 3.7.0 → 3.8.1

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

@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024-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 <couchbase/node_id.hxx>
+
+#include <cstdint>
+#include <string>
+
+namespace couchbase
+{
+
+/**
+ * Internal factory for constructing node_id instances from core-level data.
+ *
+ * This class is a friend of node_id and provides the only way to construct
+ * a non-default node_id outside the couchbase namespace.
+ */
+class internal_node_id
+{
+public:
+  static auto build(std::string node_uuid, std::string hostname, std::uint16_t port) -> node_id;
+};
+
+} // namespace couchbase

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

@@ -0,0 +1,161 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2025. 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 "observability_recorder.hxx"
+#include "core/tracing/attribute_helpers.hxx"
+
+namespace couchbase::core::impl
+{
+auto
+observability_recorder::create(std::string op_name,
+                               std::shared_ptr<couchbase::tracing::request_span> parent_span,
+                               std::weak_ptr<tracing::tracer_wrapper> tracer,
+                               std::weak_ptr<metrics::meter_wrapper> meter)
+  -> std::unique_ptr<observability_recorder>
+{
+  auto rec = std::make_unique<observability_recorder>(
+    std::move(op_name), std::move(parent_span), std::move(tracer), std::move(meter));
+  if (rec->span_->uses_tags()) {
+    rec->span_->add_tag(tracing::attributes::op::operation_name, rec->op_name_);
+  }
+  rec->metric_attributes_.operation = rec->op_name_;
+  return rec;
+}
+
+auto
+observability_recorder::operation_span() -> const std::shared_ptr<couchbase::tracing::request_span>&
+{
+  return span_;
+}
+
+void
+observability_recorder::finish(const std::error_code ec)
+{
+  metric_attributes_.ec = ec;
+  meter_.lock()->record_value(std::move(metric_attributes_), start_time_);
+  span_->end();
+}
+
+void
+observability_recorder::finish(const std::size_t retry_attempts, const std::error_code ec)
+{
+  if (span_->uses_tags()) {
+    span_->add_tag(tracing::attributes::op::retry_count, retry_attempts);
+  }
+  finish(ec);
+}
+
+auto
+observability_recorder::create_request_encoding_span() const
+  -> std::shared_ptr<couchbase::tracing::request_span>
+{
+  return tracer_.lock()->create_span(tracing::operation::step_request_encoding, span_);
+}
+
+auto
+observability_recorder::record_suboperation(std::string subop_name) const
+  -> std::unique_ptr<observability_recorder>
+{
+  return create(std::move(subop_name), span_, tracer_, meter_);
+}
+
+void
+observability_recorder::with_service(const std::string& service)
+{
+  metric_attributes_.service = service;
+  if (span_->uses_tags()) {
+    span_->add_tag(tracing::attributes::op::service, service);
+  }
+}
+
+void
+observability_recorder::with_collection_name(const std::string& collection_name)
+
+{
+  metric_attributes_.collection_name = collection_name;
+  if (span_->uses_tags()) {
+    span_->add_tag(tracing::attributes::op::collection_name, collection_name);
+  }
+}
+
+void
+observability_recorder::with_scope_name(const std::string& scope_name)
+{
+  metric_attributes_.scope_name = scope_name;
+  if (span_->uses_tags()) {
+    span_->add_tag(tracing::attributes::op::scope_name, scope_name);
+  }
+}
+
+void
+observability_recorder::with_bucket_name(const std::string& bucket_name)
+{
+  metric_attributes_.bucket_name = bucket_name;
+  if (span_->uses_tags()) {
+    span_->add_tag(tracing::attributes::op::bucket_name, bucket_name);
+  }
+}
+
+void
+observability_recorder::with_durability(const couchbase::durability_level durability)
+
+{
+  if (span_->uses_tags()) {
+    tracing::set_durability_level_attribute(span_, durability);
+  }
+}
+
+void
+observability_recorder::with_query_statement(const std::string& statement,
+                                             const query_options::built& query_options)
+
+{
+  if (query_options.positional_parameters.empty() && query_options.named_parameters.empty()) {
+    return;
+  }
+  if (span_->uses_tags()) {
+    span_->add_tag(tracing::attributes::op::query_statement, statement);
+  }
+}
+
+void
+observability_recorder::with_query_statement(const std::string& statement,
+                                             const analytics_options::built& analytics_options)
+
+{
+  if (analytics_options.positional_parameters.empty() &&
+      analytics_options.named_parameters.empty()) {
+    return;
+  }
+  if (span_->uses_tags()) {
+    span_->add_tag(tracing::attributes::op::query_statement, statement);
+  }
+}
+
+observability_recorder::observability_recorder(
+  std::string op_name,
+  std::shared_ptr<couchbase::tracing::request_span> parent_span,
+  std::weak_ptr<tracing::tracer_wrapper> tracer,
+  std::weak_ptr<metrics::meter_wrapper> meter)
+  : op_name_{ std::move(op_name) }
+  , tracer_{ std::move(tracer) }
+  , meter_{ std::move(meter) }
+  , span_{ tracer_.lock()->create_span(op_name_, std::move(parent_span)) }
+  , start_time_{ std::chrono::steady_clock::now() }
+{
+}
+} // namespace couchbase::core::impl

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

@@ -0,0 +1,77 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2025. 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 <couchbase/analytics_options.hxx>
+#include <couchbase/collection.hxx>
+#include <couchbase/durability_level.hxx>
+#include <couchbase/query_options.hxx>
+#include <couchbase/tracing/request_span.hxx>
+
+#include "core/metrics/meter_wrapper.hxx"
+#include "core/tracing/constants.hxx"
+#include "core/tracing/tracer_wrapper.hxx"
+
+#include <memory>
+#include <string>
+
+namespace couchbase::core::impl
+{
+class observability_recorder
+{
+public:
+  static auto create(std::string op_name,
+                     std::shared_ptr<couchbase::tracing::request_span> parent_span,
+                     std::weak_ptr<tracing::tracer_wrapper> tracer,
+                     std::weak_ptr<metrics::meter_wrapper> meter)
+    -> std::unique_ptr<observability_recorder>;
+
+  [[nodiscard]] auto operation_span() -> const std::shared_ptr<couchbase::tracing::request_span>&;
+
+  [[nodiscard]] auto create_request_encoding_span() const
+    -> std::shared_ptr<couchbase::tracing::request_span>;
+  [[nodiscard]] auto record_suboperation(std::string subop_name) const
+    -> std::unique_ptr<observability_recorder>;
+
+  void with_service(const std::string& service);
+  void with_collection_name(const std::string& collection_name);
+  void with_scope_name(const std::string& scope_name);
+  void with_bucket_name(const std::string& bucket_name);
+  void with_durability(couchbase::durability_level durability);
+  void with_query_statement(const std::string& statement,
+                            const query_options::built& query_options);
+  void with_query_statement(const std::string& statement,
+                            const analytics_options::built& analytics_options);
+
+  void finish(std::error_code ec);
+  void finish(std::size_t retry_attempts, std::error_code ec);
+
+  observability_recorder(std::string op_name,
+                         std::shared_ptr<couchbase::tracing::request_span> parent_span,
+                         std::weak_ptr<tracing::tracer_wrapper> tracer,
+                         std::weak_ptr<metrics::meter_wrapper> meter);
+
+private:
+  std::string op_name_;
+  std::weak_ptr<tracing::tracer_wrapper> tracer_;
+  std::weak_ptr<metrics::meter_wrapper> meter_;
+  std::shared_ptr<couchbase::tracing::request_span> span_;
+  std::chrono::time_point<std::chrono::steady_clock> start_time_;
+  metrics::metric_attributes metric_attributes_{};
+};
+} // namespace couchbase::core::impl

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

@@ -23,6 +23,7 @@
 #include "core/io/retry_context.hxx"
 #include "core/protocol/client_request.hxx"
 #include "core/protocol/cmd_observe_seqno.hxx"
+#include "core/public_fwd.hxx"
 #include "core/timeout_defaults.hxx"
 
 namespace couchbase::core::impl
@@ -59,6 +60,7 @@ struct observe_seqno_request {
   std::uint16_t partition{};
   std::uint32_t opaque{};
   io::retry_context<true> retries{};
+  std::shared_ptr<couchbase::tracing::request_span> parent_span{ nullptr };
 
   [[nodiscard]] auto encode_to(encoded_request_type& encoded,
                                core::mcbp_context&& context) const -> std::error_code;

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

@@ -18,7 +18,10 @@
 #include <couchbase/bucket.hxx>
 
 #include "core/cluster.hxx"
+#include "core/tracing/constants.hxx"
+#include "core/tracing/tracer_wrapper.hxx"
 #include "diagnostics.hxx"
+#include "observability_recorder.hxx"
 
 #include <couchbase/collection.hxx>
 #include <couchbase/collection_manager.hxx>
@@ -63,16 +66,37 @@ public:
 
   void ping(const ping_options::built& options, ping_handler&& handler) const
   {
-    return core_.ping(options.report_id,
-                      name_,
-                      core::impl::to_core_service_types(options.service_types),
-                      options.timeout,
-                      [handler = std::move(handler)](const auto& resp) mutable {
-                        return handler({}, core::impl::build_result(resp));
-                      });
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::ping, std::nullopt, options.parent_span);
+    return core_.ping(
+      options.report_id,
+      name_,
+      core::impl::to_core_service_types(options.service_types),
+      options.timeout,
+      [obs_rec = std::move(obs_rec), handler = std::move(handler)](const auto& resp) mutable {
+        obs_rec->finish({});
+        return handler({}, core::impl::build_result(resp));
+      });
   }
 
 private:
+  [[nodiscard]] auto create_observability_recorder(
+    const std::string& operation_name,
+    const std::optional<core::service_type> service,
+    const std::shared_ptr<tracing::request_span>& parent_span) const
+    -> std::unique_ptr<core::impl::observability_recorder>
+  {
+    auto rec = core::impl::observability_recorder::create(
+      operation_name, parent_span, core_.tracer(), core_.meter());
+
+    rec->with_bucket_name(name_);
+    if (service.has_value()) {
+      rec->with_service(core::tracing::service_name_for_http_service(service.value()));
+    }
+
+    return rec;
+  }
+
   core::cluster core_;
   std::string name_;
   std::shared_ptr<crypto::manager> crypto_manager_;

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

@@ -25,12 +25,15 @@
 #include "core/io/ip_protocol.hxx"
 #include "core/origin.hxx"
 #include "core/tls_verify_mode.hxx"
+#include "core/tracing/constants.hxx"
+#include "core/tracing/tracer_wrapper.hxx"
 #include "core/transactions.hxx"
 #include "core/utils/connection_string.hxx"
 #include "core/utils/movable_function.hxx"
 #include "diagnostics.hxx"
 #include "error.hxx"
 #include "internal_search_result.hxx"
+#include "observability_recorder.hxx"
 #include "query.hxx"
 #include "search.hxx"
 
@@ -87,6 +90,7 @@ options_to_origin(const std::string& connection_string, cluster_options::built o
   auth.password = std::move(opts.password);
   auth.certificate_path = std::move(opts.certificate_path);
   auth.key_path = std::move(opts.key_path);
+  auth.jwt_token = std::move(opts.jwt_token);
   auth.allowed_sasl_mechanisms = std::move(opts.allowed_sasl_mechanisms);
 
   core::cluster_options user_options;
@@ -146,6 +150,7 @@ options_to_origin(const std::string& connection_string, cluster_options::built o
   user_options.tcp_keep_alive_interval = opts.network.tcp_keep_alive_interval;
   user_options.config_poll_interval = opts.network.config_poll_interval;
   user_options.idle_http_connection_timeout = opts.network.idle_http_connection_timeout;
+  user_options.enable_lazy_connections = opts.network.enable_lazy_connections;
   if (opts.network.max_http_connections) {
     user_options.max_http_connections = opts.network.max_http_connections.value();
   }
@@ -178,8 +183,8 @@ options_to_origin(const std::string& connection_string, cluster_options::built o
   user_options.enable_tracing = opts.tracing.enabled;
   if (opts.tracing.enabled) {
     user_options.tracer = opts.tracing.tracer;
-    user_options.tracing_options.orphaned_emit_interval = opts.tracing.orphaned_emit_interval;
-    user_options.tracing_options.orphaned_sample_size = opts.tracing.orphaned_sample_size;
+    user_options.orphan_options.emit_interval = opts.tracing.orphaned_emit_interval;
+    user_options.orphan_options.sample_size = opts.tracing.orphaned_sample_size;
 
     user_options.tracing_options.threshold_emit_interval = opts.tracing.threshold_emit_interval;
     user_options.tracing_options.threshold_sample_size = opts.tracing.threshold_sample_size;
@@ -320,9 +325,16 @@ public:
 
   void query(std::string statement, query_options::built options, query_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::query, core::service_type::query, options.parent_span);
+    obs_rec->with_query_statement(statement, options);
+
+    auto request = core::impl::build_query_request(
+      std::move(statement), {}, std::move(options), obs_rec->operation_span());
+
     return core_.execute(
-      core::impl::build_query_request(std::move(statement), {}, std::move(options)),
-      [handler = std::move(handler)](auto resp) {
+      std::move(request), [obs_rec = std::move(obs_rec), handler = std::move(handler)](auto resp) {
+        obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
         return handler(core::impl::make_error(resp.ctx), core::impl::build_result(resp));
       });
   }
@@ -331,30 +343,45 @@ public:
                        analytics_options::built options,
                        analytics_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::analytics, core::service_type::analytics, options.parent_span);
+    obs_rec->with_query_statement(statement, options);
+
+    auto request = core::impl::build_analytics_request(
+      std::move(statement), std::move(options), {}, {}, obs_rec->operation_span());
+
     return core_.execute(
-      core::impl::build_analytics_request(std::move(statement), std::move(options), {}, {}),
-      [handler = std::move(handler)](auto resp) {
+      std::move(request), [obs_rec = std::move(obs_rec), handler = std::move(handler)](auto resp) {
+        obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
         return handler(core::impl::make_error(resp.ctx), core::impl::build_result(resp));
       });
   }
 
   void ping(const ping_options::built& options, ping_handler&& handler) const
   {
-    return core_.ping(options.report_id,
-                      {},
-                      core::impl::to_core_service_types(options.service_types),
-                      options.timeout,
-                      [handler = std::move(handler)](const auto& resp) mutable {
-                        return handler({}, core::impl::build_result(resp));
-                      });
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::ping, std::nullopt, options.parent_span);
+    return core_.ping(
+      options.report_id,
+      {},
+      core::impl::to_core_service_types(options.service_types),
+      options.timeout,
+      [obs_rec = std::move(obs_rec), handler = std::move(handler)](const auto& resp) mutable {
+        obs_rec->finish({});
+        return handler({}, core::impl::build_result(resp));
+      });
   };
 
   void diagnostics(const diagnostics_options::built& options, diagnostics_handler&& handler) const
   {
-    return core_.diagnostics(options.report_id,
-                             [handler = std::move(handler)](const auto& resp) mutable {
-                               return handler({}, core::impl::build_result(resp));
-                             });
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::diagnostics, std::nullopt, options.parent_span);
+    return core_.diagnostics(
+      options.report_id,
+      [obs_rec = std::move(obs_rec), handler = std::move(handler)](const auto& resp) mutable {
+        obs_rec->finish({});
+        return handler({}, core::impl::build_result(resp));
+      });
   }
 
   void search(std::string index_name,
@@ -362,14 +389,29 @@ public:
               const search_options::built& options,
               search_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::search, core::service_type::search, options.parent_span);
+
+    auto core_req = core::impl::build_search_request(
+      std::move(index_name), std::move(request), options, {}, {}, obs_rec->operation_span());
     return core_.execute(
-      core::impl::build_search_request(std::move(index_name), std::move(request), options, {}, {}),
-      [handler = std::move(handler)](const auto& resp) mutable {
+      std::move(core_req),
+      [obs_rec = std::move(obs_rec), handler = std::move(handler)](const auto& resp) mutable {
+        obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
         return handler(core::impl::make_error(resp.ctx),
                        search_result{ internal_search_result{ resp } });
       });
   }
 
+  auto set_authenticator(const core::cluster_credentials& auth) const -> error
+  {
+    auto e = core_.update_credentials(auth);
+    if (e.ec) {
+      return core::impl::make_error(e);
+    }
+    return {};
+  }
+
   void notify_fork(fork_event event)
   {
     if (event == fork_event::prepare) {
@@ -427,6 +469,20 @@ private:
     }
   }
 
+  [[nodiscard]] auto create_observability_recorder(
+    const std::string& operation_name,
+    const std::optional<core::service_type> service,
+    const std::shared_ptr<tracing::request_span>& parent_span) const
+    -> std::unique_ptr<core::impl::observability_recorder>
+  {
+    auto rec = core::impl::observability_recorder::create(
+      operation_name, parent_span, core_.tracer(), core_.meter());
+    if (service.has_value()) {
+      rec->with_service(core::tracing::service_name_for_http_service(service.value()));
+    }
+    return rec;
+  }
+
   std::string connection_string_;
   cluster_options::built options_;
   asio::io_context io_{ ASIO_CONCURRENCY_HINT_SAFE };
@@ -633,6 +689,38 @@ cluster::close() -> std::future<void>
   return future;
 }
 
+auto
+cluster::set_authenticator(const password_authenticator& authenticator) -> couchbase::error
+{
+  core::cluster_credentials auth;
+  auth.username = authenticator.username_;
+  auth.password = authenticator.password_;
+  if (authenticator.ldap_compatible_) {
+    auth.allowed_sasl_mechanisms = { { "PLAIN" } };
+  }
+
+  return impl_->set_authenticator(auth);
+}
+
+auto
+cluster::set_authenticator(const certificate_authenticator& authenticator) -> couchbase::error
+{
+  core::cluster_credentials auth;
+  auth.certificate_path = authenticator.certificate_path_;
+  auth.key_path = authenticator.key_path_;
+
+  return impl_->set_authenticator(auth);
+}
+
+auto
+cluster::set_authenticator(const jwt_authenticator& authenticator) -> error
+{
+  core::cluster_credentials auth;
+  auth.jwt_token = authenticator.token_;
+
+  return impl_->set_authenticator(auth);
+}
+
 auto
 cluster::query_indexes() const -> query_index_manager
 {

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

@@ -167,7 +167,9 @@ build_result(operations::query_response& resp) -> query_result
 auto
 build_query_request(std::string statement,
                     std::optional<std::string> query_context,
-                    query_options::built options) -> core::operations::query_request
+                    query_options::built options,
+                    std::shared_ptr<couchbase::tracing::request_span> op_span)
+  -> core::operations::query_request
 {
   operations::query_request request{
     std::move(statement),     options.adhoc,
@@ -180,7 +182,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;
+  request.parent_span = std::move(op_span);
   if (!options.raw.empty()) {
     for (auto& [name, value] : options.raw) {
       request.raw[name] = std::move(value);
@@ -232,6 +234,7 @@ build_transaction_query_result(operations::query_response resp,
 auto
 build_transaction_query_request(query_options::built opts) -> core::operations::query_request
 {
-  return core::impl::build_query_request("", {}, std::move(opts));
+  auto parent_span_from_caller = opts.parent_span;
+  return core::impl::build_query_request("", {}, std::move(opts), parent_span_from_caller);
 }
 } // namespace couchbase::core::impl

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

@@ -26,7 +26,9 @@ namespace couchbase::core::impl
 auto
 build_query_request(std::string statement,
                     std::optional<std::string> query_context,
-                    query_options::built options) -> core::operations::query_request;
+                    query_options::built options,
+                    std::shared_ptr<couchbase::tracing::request_span> op_span)
+  -> core::operations::query_request;
 
 auto
 build_result(operations::query_response& resp) -> query_result;