couchbase 3.7.0 → 3.8.0

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

@@ -18,6 +18,7 @@
 #include "core/cluster.hxx"
 
 #include "core/impl/error.hxx"
+#include "core/impl/observability_recorder.hxx"
 #include "core/operations/management/collection_create.hxx"
 #include "core/operations/management/collection_drop.hxx"
 #include "core/operations/management/collection_update.hxx"
@@ -25,6 +26,8 @@
 #include "core/operations/management/scope_drop.hxx"
 #include "core/operations/management/scope_get_all.hxx"
 #include "core/topology/collections_manifest.hxx"
+#include "core/tracing/constants.hxx"
+#include "core/tracing/tracer_wrapper.hxx"
 
 #include <couchbase/collection_manager.hxx>
 #include <couchbase/create_collection_options.hxx>
@@ -93,15 +96,19 @@ public:
                        const couchbase::drop_collection_options::built& options,
                        couchbase::drop_collection_handler&& handler) const
   {
+    auto obs_rec =
+      create_observability_recorder(core::tracing::operation::mgr_collections_drop_collection,
+                                    scope_name,
+                                    collection_name,
+                                    options.parent_span);
+    core::operations::management::collection_drop_request request{
+      bucket_name_, std::move(scope_name), std::move(collection_name),
+      {},           options.timeout,       obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::collection_drop_request{
-        bucket_name_,
-        std::move(scope_name),
-        std::move(collection_name),
-        {},
-        options.timeout,
-      },
-      [handler = std::move(handler)](const auto& resp) mutable {
+      std::move(request),
+      [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));
       });
   }
@@ -112,17 +119,20 @@ public:
                          const couchbase::update_collection_options::built& options,
                          couchbase::update_collection_handler&& handler) const
   {
+    auto obs_rec =
+      create_observability_recorder(core::tracing::operation::mgr_collections_update_collection,
+                                    scope_name,
+                                    collection_name,
+                                    options.parent_span);
+    core::operations::management::collection_update_request request{
+      bucket_name_,        std::move(scope_name),     std::move(collection_name),
+      settings.max_expiry, settings.history,          {},
+      options.timeout,     obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::collection_update_request{
-        bucket_name_,
-        std::move(scope_name),
-        std::move(collection_name),
-        settings.max_expiry,
-        settings.history,
-        {},
-        options.timeout,
-      },
-      [handler = std::move(handler)](const auto& resp) mutable {
+      std::move(request),
+      [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));
       });
   }
@@ -133,17 +143,20 @@ public:
                          const couchbase::create_collection_options::built& options,
                          couchbase::update_collection_handler&& handler) const
   {
+    auto obs_rec =
+      create_observability_recorder(core::tracing::operation::mgr_collections_create_collection,
+                                    scope_name,
+                                    collection_name,
+                                    options.parent_span);
+    core::operations::management::collection_create_request request{
+      bucket_name_,        std::move(scope_name),     std::move(collection_name),
+      settings.max_expiry, settings.history,          {},
+      options.timeout,     obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::collection_create_request{
-        bucket_name_,
-        std::move(scope_name),
-        std::move(collection_name),
-        settings.max_expiry,
-        settings.history,
-        {},
-        options.timeout,
-      },
-      [handler = std::move(handler)](const auto& resp) mutable {
+      std::move(request),
+      [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));
       });
   }
@@ -151,13 +164,18 @@ public:
   void get_all_scopes(const get_all_scopes_options::built& options,
                       get_all_scopes_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_collections_get_all_scopes, {}, {}, options.parent_span);
+    core::operations::management::scope_get_all_request request{
+      bucket_name_,
+      {},
+      options.timeout,
+      obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::scope_get_all_request{
-        bucket_name_,
-        {},
-        options.timeout,
-      },
-      [handler = std::move(handler)](auto resp) mutable {
+      std::move(request),
+      [obs_rec = std::move(obs_rec), handler = std::move(handler)](auto resp) mutable {
+        obs_rec->finish(resp.ctx.retry_attempts, resp.ctx.ec);
         return handler(core::impl::make_error(resp.ctx), map_scope_specs(resp.manifest));
       });
   }
@@ -166,14 +184,15 @@ public:
                     const couchbase::create_scope_options::built& options,
                     couchbase::create_scope_handler&& handler) const
   {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_collections_create_scope, scope_name, {}, options.parent_span);
+    core::operations::management::scope_create_request request{
+      bucket_name_, std::move(scope_name), {}, options.timeout, obs_rec->operation_span(),
+    };
     return core_.execute(
-      core::operations::management::scope_create_request{
-        bucket_name_,
-        std::move(scope_name),
-        {},
-        options.timeout,
-      },
-      [handler = std::move(handler)](const auto& resp) mutable {
+      std::move(request),
+      [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));
       });
   }
@@ -182,19 +201,40 @@ public:
                   const couchbase::drop_scope_options::built& options,
                   couchbase::drop_scope_handler&& handler) const
   {
-    core_.execute(
-      core::operations::management::scope_drop_request{
-        bucket_name_,
-        std::move(scope_name),
-        {},
-        options.timeout,
-      },
-      [handler = std::move(handler)](const auto& resp) mutable {
+    auto obs_rec = create_observability_recorder(
+      core::tracing::operation::mgr_collections_drop_scope, scope_name, {}, options.parent_span);
+    core::operations::management::scope_drop_request request{
+      bucket_name_, std::move(scope_name), {}, options.timeout, obs_rec->operation_span(),
+    };
+    return core_.execute(
+      std::move(request),
+      [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));
       });
   }
 
 private:
+  [[nodiscard]] auto create_observability_recorder(
+    const std::string& operation_name,
+    const std::optional<std::string>& scope_name,
+    const std::optional<std::string>& collection_name,
+    const std::shared_ptr<tracing::request_span>& parent_span) const
+    -> std::unique_ptr<core::impl::observability_recorder>
+  {
+    auto obs_rec = core::impl::observability_recorder::create(
+      operation_name, parent_span, core_.tracer(), core_.meter());
+    obs_rec->with_service(core::tracing::service::management);
+    obs_rec->with_bucket_name(bucket_name_);
+    if (scope_name.has_value()) {
+      obs_rec->with_scope_name(scope_name.value());
+    }
+    if (collection_name.has_value()) {
+      obs_rec->with_collection_name(collection_name.value());
+    }
+    return obs_rec;
+  }
+
   core::cluster core_;
   std::string bucket_name_;
 };

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

@@ -78,9 +78,9 @@ dns_srv_tracker::get_srv_nodes(
                                            self->address_,
                                            resp.ec.message());
                           } else if (resp.targets.empty() && self->address_ != "localhost") {
-                            CB_LOG_WARNING("DNS SRV query returned 0 records for \"{}\", assuming "
-                                           "that cluster is listening this address",
-                                           self->address_);
+                            CB_LOG_DEBUG("DNS SRV query returned 0 records for \"{}\", assuming "
+                                         "that cluster is listening this address",
+                                         self->address_);
                           } else {
                             nodes.reserve(resp.targets.size());
                             for (const auto& address : resp.targets) {
@@ -136,7 +136,7 @@ dns_srv_tracker::report_bootstrap_error(const std::string& endpoint, std::error_
 {
   bool trigger_dns_srv_refresh = false;
 
-  if (ec && ec != errc::common::request_canceled) {
+  if (ec && ec != errc::common::request_canceled && ec != errc::common::bucket_not_found) {
     const std::scoped_lock lock(known_endpoints_mutex_);
     known_endpoints_.erase(endpoint);
     if (known_endpoints_.empty()) {

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

@@ -17,6 +17,7 @@
 
 #include "error.hxx"
 
+#include "core/error.hxx"
 #include "core/error_context/analytics.hxx"
 #include "core/error_context/analytics_json.hxx"
 #include "core/error_context/http.hxx"
@@ -116,7 +117,7 @@ error::operator==(const couchbase::error& other) const -> bool
 namespace core::impl
 {
 auto
-make_error(const core::error_context::query& core_ctx) -> error
+make_error(const core::error_context::query& core_ctx) -> couchbase::error
 {
   if (!core_ctx.ec) {
     return {};
@@ -125,7 +126,7 @@ make_error(const core::error_context::query& core_ctx) -> error
 }
 
 auto
-make_error(const query_error_context& core_ctx) -> error
+make_error(const query_error_context& core_ctx) -> couchbase::error
 {
   if (!core_ctx.ec()) {
     return {};
@@ -134,7 +135,7 @@ make_error(const query_error_context& core_ctx) -> error
 }
 
 auto
-make_error(const core::error_context::search& core_ctx) -> error
+make_error(const core::error_context::search& core_ctx) -> couchbase::error
 {
   if (!core_ctx.ec) {
     return {};
@@ -143,7 +144,7 @@ make_error(const core::error_context::search& core_ctx) -> error
 }
 
 auto
-make_error(const core::error_context::analytics& core_ctx) -> error
+make_error(const core::error_context::analytics& core_ctx) -> couchbase::error
 {
   if (!core_ctx.ec) {
     return {};
@@ -152,7 +153,7 @@ make_error(const core::error_context::analytics& core_ctx) -> error
 }
 
 auto
-make_error(const core::error_context::http& core_ctx) -> error
+make_error(const core::error_context::http& core_ctx) -> couchbase::error
 {
   if (!core_ctx.ec) {
     return {};
@@ -161,7 +162,7 @@ make_error(const core::error_context::http& core_ctx) -> error
 }
 
 auto
-make_error(const couchbase::core::key_value_error_context& core_ctx) -> error
+make_error(const couchbase::core::key_value_error_context& core_ctx) -> couchbase::error
 {
   if (!core_ctx.ec()) {
     return {};
@@ -170,7 +171,7 @@ make_error(const couchbase::core::key_value_error_context& core_ctx) -> error
 }
 
 auto
-make_error(const couchbase::core::subdocument_error_context& core_ctx) -> error
+make_error(const couchbase::core::subdocument_error_context& core_ctx) -> couchbase::error
 {
   if (!core_ctx.ec()) {
     return {};
@@ -179,15 +180,15 @@ make_error(const couchbase::core::subdocument_error_context& core_ctx) -> error
 }
 
 auto
-make_error(const couchbase::core::transaction_error_context& ctx) -> error
+make_error(const couchbase::core::transaction_error_context& ctx) -> couchbase::error
 {
   return { ctx.ec(), {}, {}, { ctx.cause() } };
 }
 
 auto
-make_error(const core::transactions::op_exception& exc) -> error
+make_error(const core::transactions::op_exception& exc) -> couchbase::error
 {
-  std::optional<error> cause;
+  std::optional<couchbase::error> cause;
   if (std::holds_alternative<key_value_error_context>(exc.ctx().cause())) {
     cause = make_error(std::get<key_value_error_context>(exc.ctx().cause()));
   }
@@ -196,7 +197,7 @@ make_error(const core::transactions::op_exception& exc) -> error
   }
 
   if (cause.has_value()) {
-    return error{
+    return couchbase::error{
       transaction_op_errc_from_external_exception(exc.cause()),
       exc.what(),
       {},
@@ -204,7 +205,7 @@ make_error(const core::transactions::op_exception& exc) -> error
     };
   }
 
-  return error{
+  return couchbase::error{
     transaction_op_errc_from_external_exception(exc.cause()),
     exc.what(),
     {},
@@ -218,7 +219,13 @@ make_error(const couchbase::core::transactions::transaction_operation_failed& co
   return { couchbase::errc::transaction_op::transaction_op_failed,
            core_tof.what(),
            internal_error_context::build_error_context(tao::json::empty_object, core_tof),
-           error(transaction_op_errc_from_external_exception(core_tof.cause())) };
+           couchbase::error(transaction_op_errc_from_external_exception(core_tof.cause())) };
+}
+
+auto
+make_error(const core::error& err) -> couchbase::error
+{
+  return { err.ec, err.message };
 }
 } // namespace core::impl
 } // namespace couchbase

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

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include "core/error.hxx"
 #include "core/error_context/key_value_error_context.hxx"
 #include "core/error_context/query_error_context.hxx"
 #include "core/error_context/subdocument_error_context.hxx"
@@ -33,32 +34,36 @@
 namespace couchbase::core::impl
 {
 auto
-make_error(const core::error_context::query& core_ctx) -> error;
+make_error(const core::error_context::query& core_ctx) -> couchbase::error;
 
 auto
-make_error(const core::error_context::search& core_ctx) -> error;
+make_error(const core::error_context::search& core_ctx) -> couchbase::error;
 
 auto
-make_error(const core::error_context::analytics& core_ctx) -> error;
+make_error(const core::error_context::analytics& core_ctx) -> couchbase::error;
 
 auto
-make_error(const core::error_context::http& core_ctx) -> error;
+make_error(const core::error_context::http& core_ctx) -> couchbase::error;
 
 auto
-make_error(const couchbase::core::key_value_error_context& core_ctx) -> error;
+make_error(const couchbase::core::key_value_error_context& core_ctx) -> couchbase::error;
 
 auto
-make_error(const couchbase::core::subdocument_error_context& core_ctx) -> error;
+make_error(const couchbase::core::subdocument_error_context& core_ctx) -> couchbase::error;
 
 auto
-make_error(const couchbase::core::query_error_context& core_ctx) -> error;
+make_error(const couchbase::core::query_error_context& core_ctx) -> couchbase::error;
 
 auto
-make_error(const couchbase::core::transaction_error_context& core_ctx) -> error;
+make_error(const couchbase::core::transaction_error_context& core_ctx) -> couchbase::error;
 
 auto
-make_error(const couchbase::core::transactions::op_exception& exc) -> error;
+make_error(const couchbase::core::transactions::op_exception& exc) -> couchbase::error;
 
 auto
-make_error(const couchbase::core::transactions::transaction_operation_failed& core_tof) -> error;
+make_error(const couchbase::core::transactions::transaction_operation_failed& core_tof)
+  -> couchbase::error;
+
+auto
+make_error(const core::error& err) -> couchbase::error;
 } // namespace couchbase::core::impl

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

@@ -70,7 +70,7 @@ private:
 };
 
 using movable_get_all_replicas_handler =
-  utils::movable_function<void(error, get_all_replicas_result)>;
+  utils::movable_function<void(couchbase::error, get_all_replicas_result)>;
 
 void
 initiate_get_all_replicas_operation(std::shared_ptr<cluster> core,

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

@@ -65,7 +65,8 @@ private:
   std::optional<std::chrono::milliseconds> timeout_{};
 };
 
-using movable_get_any_replica_handler = utils::movable_function<void(error, get_replica_result)>;
+using movable_get_any_replica_handler =
+  utils::movable_function<void(couchbase::error, get_replica_result)>;
 
 void
 initiate_get_any_replica_operation(std::shared_ptr<cluster> core,

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

@@ -23,6 +23,7 @@
 #include "core/io/retry_context.hxx"
 #include "core/protocol/client_request.hxx"
 #include "core/protocol/cmd_get_replica.hxx"
+#include "core/public_fwd.hxx"
 #include "core/timeout_defaults.hxx"
 
 namespace couchbase::core::impl
@@ -48,6 +49,7 @@ struct get_replica_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/lookup_in_replica.hxx

@@ -18,6 +18,7 @@
 #pragma once
 
 #include "core/error_context/key_value.hxx"
+#include "core/error_context/subdocument_error_context.hxx"
 #include "core/impl/subdoc/command.hxx"
 #include "core/io/mcbp_context.hxx"
 #include "core/io/retry_context.hxx"
@@ -26,7 +27,6 @@
 #include "core/public_fwd.hxx"
 #include "core/timeout_defaults.hxx"
 
-#include "core/error_context/subdocument_error_context.hxx"
 #include <couchbase/lookup_in_result.hxx>
 
 namespace couchbase::core::impl

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