couchbase 3.7.0 → 3.8.0

data/ext/rcb_backend.cxx

@@ -22,6 +22,7 @@
 
 #include <core/cluster.hxx>
 #include <core/logger/logger.hxx>
+#include <core/tracing/wrapper_sdk_tracer.hxx>
 #include <core/utils/connection_string.hxx>
 
 #include <asio/io_context.hpp>
@@ -178,17 +179,21 @@ cb_Backend_allocate(VALUE klass)
 }
 
 auto
-construct_cluster_options(VALUE credentials, bool tls_enabled) -> couchbase::cluster_options
+construct_authenticator(VALUE credentials) -> std::variant<couchbase::password_authenticator,
+                                                           couchbase::certificate_authenticator,
+                                                           couchbase::jwt_authenticator>
 {
   cb_check_type(credentials, T_HASH);
 
   static const auto sym_certificate_path{ rb_id2sym(rb_intern("certificate_path")) };
   static const auto sym_key_path{ rb_id2sym(rb_intern("key_path")) };
+  static const auto sym_jwt{ rb_id2sym(rb_intern("jwt")) };
 
   const VALUE certificate_path = rb_hash_aref(credentials, sym_certificate_path);
   const VALUE key_path = rb_hash_aref(credentials, sym_key_path);
+  const VALUE jwt = rb_hash_aref(credentials, sym_jwt);
 
-  if (NIL_P(certificate_path) || NIL_P(key_path)) {
+  if (NIL_P(certificate_path) && NIL_P(key_path) && NIL_P(jwt)) {
     static const auto sym_username = rb_id2sym(rb_intern("username"));
     static const auto sym_password = rb_id2sym(rb_intern("password"));
 
@@ -198,11 +203,48 @@ construct_cluster_options(VALUE credentials, bool tls_enabled) -> couchbase::clu
     cb_check_type(username, T_STRING);
     cb_check_type(password, T_STRING);
 
-    return cluster_options{
-      password_authenticator{
-        cb_string_new(username),
-        cb_string_new(password),
-      },
+    return couchbase::password_authenticator{
+      cb_string_new(username),
+      cb_string_new(password),
+    };
+  }
+
+  if (NIL_P(jwt)) {
+    cb_check_type(certificate_path, T_STRING);
+    cb_check_type(key_path, T_STRING);
+
+    return couchbase::certificate_authenticator{
+      cb_string_new(certificate_path),
+      cb_string_new(key_path),
+    };
+  }
+
+  cb_check_type(jwt, T_STRING);
+  return couchbase::jwt_authenticator{
+    cb_string_new(jwt),
+  };
+}
+
+auto
+construct_cluster_options(VALUE credentials, bool tls_enabled) -> couchbase::cluster_options
+{
+  auto authenticator = construct_authenticator(credentials);
+
+  if (std::holds_alternative<couchbase::password_authenticator>(authenticator)) {
+    return couchbase::cluster_options{
+      std::get<couchbase::password_authenticator>(std::move(authenticator)),
+    };
+  }
+
+  if (std::holds_alternative<couchbase::jwt_authenticator>(authenticator)) {
+    if (!tls_enabled) {
+      throw ruby_exception(
+        exc_invalid_argument(),
+        "JWT authenticator requires TLS connection, check the connection string");
+    }
+
+    return couchbase::cluster_options{
+      std::get<couchbase::jwt_authenticator>(std::move(authenticator)),
     };
   }
 
@@ -212,14 +254,8 @@ construct_cluster_options(VALUE credentials, bool tls_enabled) -> couchbase::clu
       "Certificate authenticator requires TLS connection, check the connection string");
   }
 
-  cb_check_type(certificate_path, T_STRING);
-  cb_check_type(key_path, T_STRING);
-
-  return cluster_options{
-    certificate_authenticator{
-      cb_string_new(certificate_path),
-      cb_string_new(key_path),
-    },
+  return couchbase::cluster_options{
+    std::get<couchbase::certificate_authenticator>(std::move(authenticator)),
   };
 }
 
@@ -408,68 +444,46 @@ initialize_cluster_options(const core::utils::connection_string& connstr,
     cluster_options.network().max_http_connections(param.value());
   }
 
-  static const auto sym_enable_tracing = rb_id2sym(rb_intern("enable_tracing"));
-  if (auto param = options::get_bool(options, sym_enable_tracing); param) {
-    cluster_options.tracing().enable(param.value());
-  }
-  static const auto sym_orphaned_emit_interval = rb_id2sym(rb_intern("orphaned_emit_interval"));
-  if (auto param = options::get_milliseconds(options, sym_orphaned_emit_interval); param) {
-    cluster_options.tracing().orphaned_emit_interval(param.value());
-  }
-
-  static const auto sym_orphaned_sample_size = rb_id2sym(rb_intern("orphaned_sample_size"));
-  if (auto param = options::get_size_t(options, sym_orphaned_sample_size); param) {
-    cluster_options.tracing().orphaned_sample_size(param.value());
-  }
+  cluster_options.tracing().tracer(
+    std::make_shared<couchbase::core::tracing::wrapper_sdk_tracer>());
 
-  static const auto sym_threshold_emit_interval = rb_id2sym(rb_intern("threshold_emit_interval"));
-  if (auto param = options::get_milliseconds(options, sym_threshold_emit_interval); param) {
-    cluster_options.tracing().threshold_emit_interval(param.value());
-  }
+  cluster_options.metrics().enable(false); // Metrics are handled on the wrapper-side
 
-  static const auto sym_threshold_sample_size = rb_id2sym(rb_intern("threshold_sample_size"));
-  if (auto param = options::get_size_t(options, sym_threshold_sample_size); param) {
-    cluster_options.tracing().threshold_sample_size(param.value());
-  }
-
-  static const auto sym_key_value_threshold = rb_id2sym(rb_intern("key_value_threshold"));
-  if (auto param = options::get_milliseconds(options, sym_key_value_threshold); param) {
-    cluster_options.tracing().key_value_threshold(param.value());
-  }
-
-  static const auto sym_query_threshold = rb_id2sym(rb_intern("query_threshold"));
-  if (auto param = options::get_milliseconds(options, sym_query_threshold); param) {
-    cluster_options.tracing().query_threshold(param.value());
-  }
-
-  static const auto sym_view_threshold = rb_id2sym(rb_intern("view_threshold"));
-  if (auto param = options::get_milliseconds(options, sym_view_threshold); param) {
-    cluster_options.tracing().view_threshold(param.value());
-  }
-
-  static const auto sym_search_threshold = rb_id2sym(rb_intern("search_threshold"));
-  if (auto param = options::get_milliseconds(options, sym_search_threshold); param) {
-    cluster_options.tracing().search_threshold(param.value());
-  }
+  static const auto sym_app_telemetry = rb_id2sym(rb_intern("application_telemetry"));
+  if (auto app_telemetry_options = options::get_hash(options, sym_app_telemetry);
+      app_telemetry_options) {
+    static const auto sym_enable_app_telemetry = rb_id2sym(rb_intern("enable"));
+    if (auto param = options::get_bool(app_telemetry_options.value(), sym_enable_app_telemetry);
+        param) {
+      cluster_options.application_telemetry().enable(param.value());
+    }
 
-  static const auto sym_analytics_threshold = rb_id2sym(rb_intern("analytics_threshold"));
-  if (auto param = options::get_milliseconds(options, sym_analytics_threshold); param) {
-    cluster_options.tracing().analytics_threshold(param.value());
-  }
+    static const auto sym_app_telemetry_endpoint = rb_id2sym(rb_intern("override_endpoint"));
+    if (auto param = options::get_string(app_telemetry_options.value(), sym_app_telemetry_endpoint);
+        param) {
+      cluster_options.application_telemetry().override_endpoint(param.value());
+    }
 
-  static const auto sym_management_threshold = rb_id2sym(rb_intern("management_threshold"));
-  if (auto param = options::get_milliseconds(options, sym_management_threshold); param) {
-    cluster_options.tracing().management_threshold(param.value());
-  }
+    static const auto sym_app_telemetry_backoff = rb_id2sym(rb_intern("backoff"));
+    if (auto param =
+          options::get_milliseconds(app_telemetry_options.value(), sym_app_telemetry_backoff);
+        param) {
+      cluster_options.application_telemetry().backoff_interval(param.value());
+    }
 
-  static const auto sym_enable_metrics = rb_id2sym(rb_intern("enable_metrics"));
-  if (auto param = options::get_bool(options, sym_enable_metrics); param) {
-    cluster_options.metrics().enable(param.value());
-  }
+    static const auto sym_app_telemetry_ping_interval = rb_id2sym(rb_intern("ping_interval"));
+    if (auto param =
+          options::get_milliseconds(app_telemetry_options.value(), sym_app_telemetry_ping_interval);
+        param) {
+      cluster_options.application_telemetry().ping_interval(param.value());
+    }
 
-  static const auto sym_metrics_emit_interval = rb_id2sym(rb_intern("metrics_emit_interval"));
-  if (auto param = options::get_milliseconds(options, sym_metrics_emit_interval); param) {
-    cluster_options.metrics().emit_interval(param.value());
+    static const auto sym_app_telemetry_ping_timeout = rb_id2sym(rb_intern("ping_timeout"));
+    if (auto param =
+          options::get_milliseconds(app_telemetry_options.value(), sym_app_telemetry_ping_timeout);
+        param) {
+      cluster_options.application_telemetry().ping_timeout(param.value());
+    }
   }
 
   return cluster_options;
@@ -573,6 +587,38 @@ cb_Backend_open_bucket(VALUE self, VALUE bucket, VALUE wait_until_ready)
   return Qnil;
 }
 
+VALUE
+cb_Backend_update_credentials(VALUE self, VALUE credentials)
+{
+  auto cluster = cb_backend_to_public_api_cluster(self);
+
+  try {
+    auto authenticator = construct_authenticator(credentials);
+
+    couchbase::error err{};
+    if (std::holds_alternative<couchbase::password_authenticator>(authenticator)) {
+      err = cluster.set_authenticator(
+        std::get<couchbase::password_authenticator>(std::move(authenticator)));
+    } else if (std::holds_alternative<couchbase::jwt_authenticator>(authenticator)) {
+      err =
+        cluster.set_authenticator(std::get<couchbase::jwt_authenticator>(std::move(authenticator)));
+    } else {
+      err = cluster.set_authenticator(
+        std::get<couchbase::certificate_authenticator>(std::move(authenticator)));
+    }
+    if (err) {
+      cb_throw_error(err, "failed to update authenticator");
+    }
+  } catch (const std::system_error& se) {
+    rb_exc_raise(cb_map_error_code(
+      se.code(), fmt::format("failed to update authenticator {}: {}", __func__, se.what()), false));
+  } catch (const ruby_exception& e) {
+    rb_exc_raise(e.exception_object());
+  }
+
+  return Qnil;
+}
+
 } // namespace
 
 VALUE
@@ -583,6 +629,7 @@ init_backend(VALUE mCouchbase)
   rb_define_method(cBackend, "open", cb_Backend_open, 3);
   rb_define_method(cBackend, "open_bucket", cb_Backend_open_bucket, 2);
   rb_define_method(cBackend, "close", cb_Backend_close, 0);
+  rb_define_method(cBackend, "update_credentials", cb_Backend_update_credentials, 1);
 
   rb_define_singleton_method(cBackend, "notify_fork", cb_Backend_notify_fork, 1);
   return cBackend;

data/ext/rcb_buckets.cxx

@@ -32,6 +32,7 @@
 #include <ruby.h>
 
 #include "rcb_backend.hxx"
+#include "rcb_observability.hxx"
 #include "rcb_utils.hxx"
 
 namespace couchbase::ruby
@@ -273,7 +274,10 @@ cb_generate_bucket_settings(VALUE bucket,
 }
 
 VALUE
-cb_Backend_bucket_create(VALUE self, VALUE bucket_settings, VALUE options)
+cb_Backend_bucket_create(VALUE self,
+                         VALUE bucket_settings,
+                         VALUE options,
+                         VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -286,12 +290,15 @@ cb_Backend_bucket_create(VALUE self, VALUE bucket_settings, VALUE options)
     core::operations::management::bucket_create_request req{};
     cb_extract_timeout(req, options);
     cb_generate_bucket_settings(bucket_settings, req.bucket, true);
+    auto parent_span = cb_create_parent_span(req, self);
     std::promise<core::operations::management::bucket_create_response> promise;
     auto f = promise.get_future();
     cluster.execute(req, [promise = std::move(promise)](auto&& resp) mutable {
       promise.set_value(std::forward<decltype(resp)>(resp));
     });
-    if (auto resp = cb_wait_for_future(f); resp.ctx.ec) {
+    auto resp = cb_wait_for_future(f);
+    cb_add_core_spans(observability_handler, std::move(parent_span), resp.ctx.retry_attempts);
+    if (resp.ctx.ec) {
       cb_throw_error(resp.ctx,
                      fmt::format("unable to create bucket \"{}\" on the cluster ({})",
                                  req.bucket.name,
@@ -309,7 +316,10 @@ cb_Backend_bucket_create(VALUE self, VALUE bucket_settings, VALUE options)
 }
 
 VALUE
-cb_Backend_bucket_update(VALUE self, VALUE bucket_settings, VALUE options)
+cb_Backend_bucket_update(VALUE self,
+                         VALUE bucket_settings,
+                         VALUE options,
+                         VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -321,12 +331,15 @@ cb_Backend_bucket_update(VALUE self, VALUE bucket_settings, VALUE options)
     core::operations::management::bucket_update_request req{};
     cb_extract_timeout(req, options);
     cb_generate_bucket_settings(bucket_settings, req.bucket, false);
+    auto parent_span = cb_create_parent_span(req, self);
     std::promise<core::operations::management::bucket_update_response> promise;
     auto f = promise.get_future();
     cluster.execute(req, [promise = std::move(promise)](auto&& resp) mutable {
       promise.set_value(std::forward<decltype(resp)>(resp));
     });
-    if (auto resp = cb_wait_for_future(f); resp.ctx.ec) {
+    auto resp = cb_wait_for_future(f);
+    cb_add_core_spans(observability_handler, std::move(parent_span), resp.ctx.retry_attempts);
+    if (resp.ctx.ec) {
       cb_throw_error(resp.ctx,
                      fmt::format("unable to update bucket \"{}\" on the cluster ({})",
                                  req.bucket.name,
@@ -343,7 +356,7 @@ cb_Backend_bucket_update(VALUE self, VALUE bucket_settings, VALUE options)
 }
 
 VALUE
-cb_Backend_bucket_drop(VALUE self, VALUE bucket_name, VALUE options)
+cb_Backend_bucket_drop(VALUE self, VALUE bucket_name, VALUE options, VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -355,12 +368,15 @@ cb_Backend_bucket_drop(VALUE self, VALUE bucket_name, VALUE options)
   try {
     core::operations::management::bucket_drop_request req{ cb_string_new(bucket_name) };
     cb_extract_timeout(req, options);
+    auto parent_span = cb_create_parent_span(req, self);
     std::promise<core::operations::management::bucket_drop_response> promise;
     auto f = promise.get_future();
     cluster.execute(req, [promise = std::move(promise)](auto&& resp) mutable {
       promise.set_value(std::forward<decltype(resp)>(resp));
     });
-    if (auto resp = cb_wait_for_future(f); resp.ctx.ec) {
+    auto resp = cb_wait_for_future(f);
+    cb_add_core_spans(observability_handler, std::move(parent_span), resp.ctx.retry_attempts);
+    if (resp.ctx.ec) {
       cb_throw_error(resp.ctx,
                      fmt::format("unable to remove bucket \"{}\" on the cluster", req.name));
     }
@@ -375,7 +391,7 @@ cb_Backend_bucket_drop(VALUE self, VALUE bucket_name, VALUE options)
 }
 
 VALUE
-cb_Backend_bucket_flush(VALUE self, VALUE bucket_name, VALUE options)
+cb_Backend_bucket_flush(VALUE self, VALUE bucket_name, VALUE options, VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -387,12 +403,15 @@ cb_Backend_bucket_flush(VALUE self, VALUE bucket_name, VALUE options)
   try {
     core::operations::management::bucket_flush_request req{ cb_string_new(bucket_name) };
     cb_extract_timeout(req, options);
+    auto parent_span = cb_create_parent_span(req, self);
     std::promise<core::operations::management::bucket_flush_response> promise;
     auto f = promise.get_future();
     cluster.execute(req, [promise = std::move(promise)](auto&& resp) mutable {
       promise.set_value(std::forward<decltype(resp)>(resp));
     });
-    if (auto resp = cb_wait_for_future(f); resp.ctx.ec) {
+    auto resp = cb_wait_for_future(f);
+    cb_add_core_spans(observability_handler, std::move(parent_span), resp.ctx.retry_attempts);
+    if (resp.ctx.ec) {
       cb_throw_error(resp.ctx,
                      fmt::format("unable to flush bucket \"{}\" on the cluster", req.name));
     }
@@ -562,7 +581,7 @@ cb_extract_bucket_settings(const core::management::cluster::bucket_settings& ent
 }
 
 VALUE
-cb_Backend_bucket_get_all(VALUE self, VALUE options)
+cb_Backend_bucket_get_all(VALUE self, VALUE options, VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -573,12 +592,14 @@ cb_Backend_bucket_get_all(VALUE self, VALUE options)
   try {
     core::operations::management::bucket_get_all_request req{};
     cb_extract_timeout(req, options);
+    auto parent_span = cb_create_parent_span(req, self);
     std::promise<core::operations::management::bucket_get_all_response> promise;
     auto f = promise.get_future();
     cluster.execute(req, [promise = std::move(promise)](auto&& resp) mutable {
       promise.set_value(std::forward<decltype(resp)>(resp));
     });
     auto resp = cb_wait_for_future(f);
+    cb_add_core_spans(observability_handler, std::move(parent_span), resp.ctx.retry_attempts);
     if (resp.ctx.ec) {
       cb_throw_error(resp.ctx, "unable to get list of the buckets of the cluster");
     }
@@ -601,7 +622,7 @@ cb_Backend_bucket_get_all(VALUE self, VALUE options)
 }
 
 VALUE
-cb_Backend_bucket_get(VALUE self, VALUE bucket_name, VALUE options)
+cb_Backend_bucket_get(VALUE self, VALUE bucket_name, VALUE options, VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -613,12 +634,14 @@ cb_Backend_bucket_get(VALUE self, VALUE bucket_name, VALUE options)
   try {
     core::operations::management::bucket_get_request req{ cb_string_new(bucket_name) };
     cb_extract_timeout(req, options);
+    auto parent_span = cb_create_parent_span(req, self);
     std::promise<core::operations::management::bucket_get_response> promise;
     auto f = promise.get_future();
     cluster.execute(req, [promise = std::move(promise)](auto&& resp) mutable {
       promise.set_value(std::forward<decltype(resp)>(resp));
     });
     auto resp = cb_wait_for_future(f);
+    cb_add_core_spans(observability_handler, std::move(parent_span), resp.ctx.retry_attempts);
     if (resp.ctx.ec) {
       cb_throw_error(resp.ctx,
                      fmt::format("unable to locate bucket \"{}\" on the cluster", req.name));
@@ -640,11 +663,11 @@ cb_Backend_bucket_get(VALUE self, VALUE bucket_name, VALUE options)
 void
 init_buckets(VALUE cBackend)
 {
-  rb_define_method(cBackend, "bucket_create", cb_Backend_bucket_create, 2);
-  rb_define_method(cBackend, "bucket_update", cb_Backend_bucket_update, 2);
-  rb_define_method(cBackend, "bucket_drop", cb_Backend_bucket_drop, 2);
-  rb_define_method(cBackend, "bucket_flush", cb_Backend_bucket_flush, 2);
-  rb_define_method(cBackend, "bucket_get_all", cb_Backend_bucket_get_all, 1);
-  rb_define_method(cBackend, "bucket_get", cb_Backend_bucket_get, 2);
+  rb_define_method(cBackend, "bucket_create", cb_Backend_bucket_create, 3);
+  rb_define_method(cBackend, "bucket_update", cb_Backend_bucket_update, 3);
+  rb_define_method(cBackend, "bucket_drop", cb_Backend_bucket_drop, 3);
+  rb_define_method(cBackend, "bucket_flush", cb_Backend_bucket_flush, 3);
+  rb_define_method(cBackend, "bucket_get_all", cb_Backend_bucket_get_all, 2);
+  rb_define_method(cBackend, "bucket_get", cb_Backend_bucket_get, 3);
 }
 } // namespace couchbase::ruby

data/ext/rcb_collections.cxx

@@ -31,6 +31,7 @@
 #include <ruby.h>
 
 #include "rcb_backend.hxx"
+#include "rcb_observability.hxx"
 #include "rcb_utils.hxx"
 
 namespace couchbase::ruby
@@ -38,7 +39,7 @@ namespace couchbase::ruby
 namespace
 {
 VALUE
-cb_Backend_scope_get_all(VALUE self, VALUE bucket_name, VALUE options)
+cb_Backend_scope_get_all(VALUE self, VALUE bucket_name, VALUE options, VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -50,12 +51,14 @@ cb_Backend_scope_get_all(VALUE self, VALUE bucket_name, VALUE options)
   try {
     core::operations::management::scope_get_all_request req{ cb_string_new(bucket_name) };
     cb_extract_timeout(req, options);
+    auto parent_span = cb_create_parent_span(req, self);
     std::promise<core::operations::management::scope_get_all_response> promise;
     auto f = promise.get_future();
     cluster.execute(req, [promise = std::move(promise)](auto&& resp) mutable {
       promise.set_value(std::forward<decltype(resp)>(resp));
     });
     auto resp = cb_wait_for_future(f);
+    cb_add_core_spans(observability_handler, std::move(parent_span), resp.ctx.retry_attempts);
     if (resp.ctx.ec) {
       cb_throw_error(
         resp.ctx,
@@ -97,7 +100,11 @@ cb_Backend_scope_get_all(VALUE self, VALUE bucket_name, VALUE options)
 }
 
 VALUE
-cb_Backend_scope_create(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE options)
+cb_Backend_scope_create(VALUE self,
+                        VALUE bucket_name,
+                        VALUE scope_name,
+                        VALUE options,
+                        VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -111,12 +118,14 @@ cb_Backend_scope_create(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE o
     core::operations::management::scope_create_request req{ cb_string_new(bucket_name),
                                                             cb_string_new(scope_name) };
     cb_extract_timeout(req, options);
+    auto parent_span = cb_create_parent_span(req, self);
     std::promise<core::operations::management::scope_create_response> promise;
     auto f = promise.get_future();
     cluster.execute(req, [promise = std::move(promise)](auto&& resp) mutable {
       promise.set_value(std::forward<decltype(resp)>(resp));
     });
     auto resp = cb_wait_for_future(f);
+    cb_add_core_spans(observability_handler, std::move(parent_span), resp.ctx.retry_attempts);
 
     if (resp.ctx.ec) {
       cb_throw_error(resp.ctx,
@@ -135,7 +144,11 @@ cb_Backend_scope_create(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE o
 }
 
 VALUE
-cb_Backend_scope_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE options)
+cb_Backend_scope_drop(VALUE self,
+                      VALUE bucket_name,
+                      VALUE scope_name,
+                      VALUE options,
+                      VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -149,12 +162,14 @@ cb_Backend_scope_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE opt
     core::operations::management::scope_drop_request req{ cb_string_new(bucket_name),
                                                           cb_string_new(scope_name) };
     cb_extract_timeout(req, options);
+    auto parent_span = cb_create_parent_span(req, self);
     std::promise<core::operations::management::scope_drop_response> promise;
     auto f = promise.get_future();
     cluster.execute(req, [promise = std::move(promise)](auto&& resp) mutable {
       promise.set_value(std::forward<decltype(resp)>(resp));
     });
     auto resp = cb_wait_for_future(f);
+    cb_add_core_spans(observability_handler, std::move(parent_span), resp.ctx.retry_attempts);
     if (resp.ctx.ec) {
       cb_throw_error(resp.ctx,
                      fmt::format(R"(unable to drop the scope "{}" on the bucket "{}")",
@@ -177,7 +192,8 @@ cb_Backend_collection_create(VALUE self,
                              VALUE scope_name,
                              VALUE collection_name,
                              VALUE settings,
-                             VALUE options)
+                             VALUE options,
+                             VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -220,6 +236,7 @@ cb_Backend_collection_create(VALUE self,
         req.history = RTEST(history);
       }
     }
+    auto parent_span = cb_create_parent_span(req, self);
 
     std::promise<core::operations::management::collection_create_response> promise;
     auto f = promise.get_future();
@@ -227,6 +244,7 @@ cb_Backend_collection_create(VALUE self,
       promise.set_value(std::forward<decltype(resp)>(resp));
     });
     auto resp = cb_wait_for_future(f);
+    cb_add_core_spans(observability_handler, std::move(parent_span), resp.ctx.retry_attempts);
     if (resp.ctx.ec) {
       cb_throw_error(resp.ctx,
                      fmt::format(R"(unable create the collection "{}.{}" on the bucket "{}")",
@@ -250,7 +268,8 @@ cb_Backend_collection_update(VALUE self,
                              VALUE scope_name,
                              VALUE collection_name,
                              VALUE settings,
-                             VALUE options)
+                             VALUE options,
+                             VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -293,6 +312,7 @@ cb_Backend_collection_update(VALUE self,
         req.history = RTEST(history);
       }
     }
+    auto parent_span = cb_create_parent_span(req, self);
 
     std::promise<core::operations::management::collection_update_response> promise;
     auto f = promise.get_future();
@@ -300,6 +320,7 @@ cb_Backend_collection_update(VALUE self,
       promise.set_value(std::forward<decltype(resp)>(resp));
     });
     auto resp = cb_wait_for_future(f);
+    cb_add_core_spans(observability_handler, std::move(parent_span), resp.ctx.retry_attempts);
     if (resp.ctx.ec) {
       cb_throw_error(resp.ctx,
                      fmt::format(R"(unable update the collection "{}.{}" on the bucket "{}")",
@@ -322,7 +343,8 @@ cb_Backend_collection_drop(VALUE self,
                            VALUE bucket_name,
                            VALUE scope_name,
                            VALUE collection_name,
-                           VALUE options)
+                           VALUE options,
+                           VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -338,6 +360,7 @@ cb_Backend_collection_drop(VALUE self,
                                                                cb_string_new(scope_name),
                                                                cb_string_new(collection_name) };
     cb_extract_timeout(req, options);
+    auto parent_span = cb_create_parent_span(req, self);
 
     std::promise<core::operations::management::collection_drop_response> promise;
     auto f = promise.get_future();
@@ -345,6 +368,7 @@ cb_Backend_collection_drop(VALUE self,
       promise.set_value(std::forward<decltype(resp)>(resp));
     });
     auto resp = cb_wait_for_future(f);
+    cb_add_core_spans(observability_handler, std::move(parent_span), resp.ctx.retry_attempts);
     if (resp.ctx.ec) {
       cb_throw_error(resp.ctx,
                      fmt::format(R"(unable to drop the collection  "{}.{}" on the bucket "{}")",
@@ -367,11 +391,11 @@ cb_Backend_collection_drop(VALUE self,
 void
 init_collections(VALUE cBackend)
 {
-  rb_define_method(cBackend, "scope_get_all", cb_Backend_scope_get_all, 2);
-  rb_define_method(cBackend, "scope_create", cb_Backend_scope_create, 3);
-  rb_define_method(cBackend, "scope_drop", cb_Backend_scope_drop, 3);
-  rb_define_method(cBackend, "collection_create", cb_Backend_collection_create, 5);
-  rb_define_method(cBackend, "collection_update", cb_Backend_collection_update, 5);
-  rb_define_method(cBackend, "collection_drop", cb_Backend_collection_drop, 4);
+  rb_define_method(cBackend, "scope_get_all", cb_Backend_scope_get_all, 3);
+  rb_define_method(cBackend, "scope_create", cb_Backend_scope_create, 4);
+  rb_define_method(cBackend, "scope_drop", cb_Backend_scope_drop, 4);
+  rb_define_method(cBackend, "collection_create", cb_Backend_collection_create, 6);
+  rb_define_method(cBackend, "collection_update", cb_Backend_collection_update, 6);
+  rb_define_method(cBackend, "collection_drop", cb_Backend_collection_drop, 5);
 }
 } // namespace couchbase::ruby