couchbase 3.7.0 → 3.8.1

data/ext/rcb_crud.cxx

@@ -17,6 +17,8 @@
 
 #include <core/cluster.hxx>
 #include <core/impl/subdoc/path_flags.hxx>
+#include <core/operations/document_append.hxx>
+#include <core/operations/document_decrement.hxx>
 #include <core/operations/document_exists.hxx>
 #include <core/operations/document_get.hxx>
 #include <core/operations/document_get_all_replicas.hxx>
@@ -24,11 +26,18 @@
 #include <core/operations/document_get_and_touch.hxx>
 #include <core/operations/document_get_any_replica.hxx>
 #include <core/operations/document_get_projected.hxx>
+#include <core/operations/document_increment.hxx>
+#include <core/operations/document_insert.hxx>
 #include <core/operations/document_lookup_in.hxx>
 #include <core/operations/document_lookup_in_all_replicas.hxx>
 #include <core/operations/document_lookup_in_any_replica.hxx>
+#include <core/operations/document_mutate_in.hxx>
+#include <core/operations/document_prepend.hxx>
+#include <core/operations/document_remove.hxx>
+#include <core/operations/document_replace.hxx>
 #include <core/operations/document_touch.hxx>
 #include <core/operations/document_unlock.hxx>
+#include <core/operations/document_upsert.hxx>
 #include <core/utils/json.hxx>
 
 #include <couchbase/cluster.hxx>
@@ -41,6 +50,7 @@
 #include <ruby.h>
 
 #include "rcb_backend.hxx"
+#include "rcb_observability.hxx"
 #include "rcb_utils.hxx"
 
 namespace couchbase
@@ -77,7 +87,8 @@ cb_Backend_document_get(VALUE self,
                         VALUE scope,
                         VALUE collection,
                         VALUE id,
-                        VALUE options)
+                        VALUE options,
+                        VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -96,12 +107,16 @@ cb_Backend_document_get(VALUE self,
 
     core::operations::get_request req{ doc_id };
     cb_extract_timeout(req, options);
+
+    auto parent_span = cb_create_parent_span(req, self);
+
     std::promise<core::operations::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, "unable to fetch document");
     }
@@ -126,7 +141,8 @@ cb_Backend_document_get_any_replica(VALUE self,
                                     VALUE scope,
                                     VALUE collection,
                                     VALUE id,
-                                    VALUE options)
+                                    VALUE options,
+                                    VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -147,12 +163,15 @@ cb_Backend_document_get_any_replica(VALUE self,
     cb_extract_timeout(req, options);
     cb_extract_read_preference(req, options);
 
+    auto parent_span = cb_create_parent_span(req, self);
+
     std::promise<core::operations::get_any_replica_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 replica of the document");
     }
@@ -178,7 +197,8 @@ cb_Backend_document_get_all_replicas(VALUE self,
                                      VALUE scope,
                                      VALUE collection,
                                      VALUE id,
-                                     VALUE options)
+                                     VALUE options,
+                                     VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -199,12 +219,15 @@ cb_Backend_document_get_all_replicas(VALUE self,
     cb_extract_timeout(req, options);
     cb_extract_read_preference(req, options);
 
+    auto parent_span = cb_create_parent_span(req, self);
+
     std::promise<core::operations::get_all_replicas_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 all replicas for the document");
     }
@@ -235,7 +258,8 @@ cb_Backend_document_get_projected(VALUE self,
                                   VALUE scope,
                                   VALUE collection,
                                   VALUE id,
-                                  VALUE options)
+                                  VALUE options,
+                                  VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -257,6 +281,7 @@ cb_Backend_document_get_projected(VALUE self,
 
     core::operations::get_projected_request req{ doc_id };
     cb_extract_timeout(req, options);
+    auto parent_span = cb_create_parent_span(req, self);
     cb_extract_option_bool(req.with_expiry, options, "with_expiry");
     cb_extract_option_bool(req.preserve_array_indexes, options, "preserve_array_indexes");
     VALUE projections = Qnil;
@@ -280,6 +305,7 @@ cb_Backend_document_get_projected(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, "unable fetch with projections");
     }
@@ -308,7 +334,8 @@ cb_Backend_document_get_and_lock(VALUE self,
                                  VALUE collection,
                                  VALUE id,
                                  VALUE lock_time,
-                                 VALUE options)
+                                 VALUE options,
+                                 VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -333,12 +360,15 @@ cb_Backend_document_get_and_lock(VALUE self,
     cb_extract_timeout(req, options);
     req.lock_time = NUM2UINT(lock_time);
 
+    auto parent_span = cb_create_parent_span(req, self);
+
     std::promise<core::operations::get_and_lock_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 lock and fetch");
     }
@@ -364,7 +394,8 @@ cb_Backend_document_get_and_touch(VALUE self,
                                   VALUE collection,
                                   VALUE id,
                                   VALUE expiry,
-                                  VALUE options)
+                                  VALUE options,
+                                  VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -389,12 +420,15 @@ cb_Backend_document_get_and_touch(VALUE self,
     auto [type, duration] = unpack_expiry(expiry, false);
     req.expiry = static_cast<std::uint32_t>(duration.count());
 
+    auto parent_span = cb_create_parent_span(req, self);
+
     std::promise<core::operations::get_and_touch_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 fetch and touch");
     }
@@ -420,7 +454,8 @@ cb_Backend_document_touch(VALUE self,
                           VALUE collection,
                           VALUE id,
                           VALUE expiry,
-                          VALUE options)
+                          VALUE options,
+                          VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -445,12 +480,15 @@ cb_Backend_document_touch(VALUE self,
     auto [type, duration] = unpack_expiry(expiry, false);
     req.expiry = static_cast<std::uint32_t>(duration.count());
 
+    auto parent_span = cb_create_parent_span(req, self);
+
     std::promise<core::operations::touch_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 touch");
     }
@@ -473,7 +511,8 @@ cb_Backend_document_exists(VALUE self,
                            VALUE scope,
                            VALUE collection,
                            VALUE id,
-                           VALUE options)
+                           VALUE options,
+                           VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -496,12 +535,15 @@ cb_Backend_document_exists(VALUE self,
     core::operations::exists_request req{ doc_id };
     cb_extract_timeout(req, options);
 
+    auto parent_span = cb_create_parent_span(req, self);
+
     std::promise<core::operations::exists_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() && resp.ctx.ec() != couchbase::errc::key_value::document_not_found) {
       cb_throw_error(resp.ctx, "unable to exists");
     }
@@ -531,11 +573,13 @@ cb_Backend_document_unlock(VALUE self,
                            VALUE collection,
                            VALUE id,
                            VALUE cas,
-                           VALUE options)
+                           VALUE options,
+                           VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
   Check_Type(bucket, T_STRING);
+  Check_Type(scope, T_STRING);
   Check_Type(collection, T_STRING);
   Check_Type(id, T_STRING);
   if (!NIL_P(options)) {
@@ -548,19 +592,21 @@ cb_Backend_document_unlock(VALUE self,
       cb_string_new(scope),
       cb_string_new(collection),
       cb_string_new(id),
-
     };
 
     core::operations::unlock_request req{ doc_id };
     cb_extract_timeout(req, options);
     cb_extract_cas(req.cas, cas);
 
+    auto parent_span = cb_create_parent_span(req, self);
+
     std::promise<core::operations::unlock_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 unlock");
     }
@@ -585,9 +631,10 @@ cb_Backend_document_upsert(VALUE self,
                            VALUE id,
                            VALUE content,
                            VALUE flags,
-                           VALUE options)
+                           VALUE options,
+                           VALUE observability_handler)
 {
-  auto cluster = cb_backend_to_public_api_cluster(self);
+  auto cluster = cb_backend_to_core_api_cluster(self);
 
   Check_Type(bucket, T_STRING);
   Check_Type(scope, T_STRING);
@@ -600,25 +647,51 @@ cb_Backend_document_upsert(VALUE self,
   }
 
   try {
-    couchbase::upsert_options opts;
-    set_timeout(opts, options);
-    set_expiry(opts, options);
-    set_durability(opts, options);
-    set_preserve_expiry(opts, options);
-
-    auto f = cluster.bucket(cb_string_new(bucket))
-               .scope(cb_string_new(scope))
-               .collection(cb_string_new(collection))
-               .upsert(cb_string_new(id),
-                       couchbase::codec::encoded_value{ cb_binary_new(content), FIX2UINT(flags) },
-                       opts);
-
-    auto [ctx, resp] = cb_wait_for_future(f);
-    if (ctx.ec()) {
-      cb_throw_error(ctx, "unable to upsert");
+    core::operations::upsert_request req{
+      core::document_id{
+        cb_string_new(bucket),
+        cb_string_new(scope),
+        cb_string_new(collection),
+        cb_string_new(id),
+      },
+    };
+    cb_extract_content(req, content);
+    cb_extract_flags(req, flags);
+    cb_extract_timeout(req, options);
+    cb_extract_expiry(req, options);
+    cb_extract_durability_level(req, options);
+    cb_extract_preserve_expiry(req, options);
+
+    auto parent_span = cb_create_parent_span(req, self);
+
+    std::promise<core::operations::upsert_response> promise;
+    auto f = promise.get_future();
+
+    if (const auto legacy_durability = extract_legacy_durability_constraints(options);
+        legacy_durability.has_value()) {
+      cluster.execute(
+        core::operations::upsert_request_with_legacy_durability{
+          std::move(req),
+          legacy_durability.value().first,
+          legacy_durability.value().second,
+        },
+        [promise = std::move(promise)](auto&& resp) mutable {
+          promise.set_value(std::forward<decltype(resp)>(resp));
+        });
+    } else {
+      cluster.execute(std::move(req), [promise = std::move(promise)](auto&& resp) mutable {
+        promise.set_value(std::forward<decltype(resp)>(resp));
+      });
     }
 
-    return to_mutation_result_value(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 upsert");
+    }
+
+    return cb_create_mutation_result(resp);
+
   } catch (const std::system_error& se) {
     rb_exc_raise(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
@@ -635,9 +708,10 @@ cb_Backend_document_append(VALUE self,
                            VALUE collection,
                            VALUE id,
                            VALUE content,
-                           VALUE options)
+                           VALUE options,
+                           VALUE observability_handler)
 {
-  auto cluster = cb_backend_to_public_api_cluster(self);
+  auto cluster = cb_backend_to_core_api_cluster(self);
 
   Check_Type(bucket, T_STRING);
   Check_Type(scope, T_STRING);
@@ -649,22 +723,49 @@ cb_Backend_document_append(VALUE self,
   }
 
   try {
-    couchbase::append_options opts;
-    set_timeout(opts, options);
-    set_durability(opts, options);
-
-    auto f = cluster.bucket(cb_string_new(bucket))
-               .scope(cb_string_new(scope))
-               .collection(cb_string_new(collection))
-               .binary()
-               .append(cb_string_new(id), cb_binary_new(content), opts);
-
-    auto [ctx, resp] = cb_wait_for_future(f);
-    if (ctx.ec()) {
-      cb_throw_error(ctx, "unable to append");
+    core::operations::append_request req{
+      core::document_id{
+        cb_string_new(bucket),
+        cb_string_new(scope),
+        cb_string_new(collection),
+        cb_string_new(id),
+      },
+    };
+    cb_extract_content(req, content);
+    cb_extract_timeout(req, options);
+    cb_extract_durability_level(req, options);
+    cb_extract_cas(req, options);
+
+    auto parent_span = cb_create_parent_span(req, self);
+
+    std::promise<core::operations::append_response> promise;
+    auto f = promise.get_future();
+
+    if (const auto legacy_durability = extract_legacy_durability_constraints(options);
+        legacy_durability.has_value()) {
+      cluster.execute(
+        core::operations::append_request_with_legacy_durability{
+          std::move(req),
+          legacy_durability.value().first,
+          legacy_durability.value().second,
+        },
+        [promise = std::move(promise)](auto&& resp) mutable {
+          promise.set_value(std::forward<decltype(resp)>(resp));
+        });
+    } else {
+      cluster.execute(std::move(req), [promise = std::move(promise)](auto&& resp) mutable {
+        promise.set_value(std::forward<decltype(resp)>(resp));
+      });
     }
 
-    return to_mutation_result_value(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 append");
+    }
+
+    return cb_create_mutation_result(resp);
+
   } catch (const std::system_error& se) {
     rb_exc_raise(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
@@ -681,9 +782,10 @@ cb_Backend_document_prepend(VALUE self,
                             VALUE collection,
                             VALUE id,
                             VALUE content,
-                            VALUE options)
+                            VALUE options,
+                            VALUE observability_handler)
 {
-  auto cluster = cb_backend_to_public_api_cluster(self);
+  auto cluster = cb_backend_to_core_api_cluster(self);
 
   Check_Type(bucket, T_STRING);
   Check_Type(scope, T_STRING);
@@ -695,22 +797,48 @@ cb_Backend_document_prepend(VALUE self,
   }
 
   try {
-    couchbase::prepend_options opts;
-    set_timeout(opts, options);
-    set_durability(opts, options);
-
-    auto f = cluster.bucket(cb_string_new(bucket))
-               .scope(cb_string_new(scope))
-               .collection(cb_string_new(collection))
-               .binary()
-               .prepend(cb_string_new(id), cb_binary_new(content), opts);
-
-    auto [ctx, resp] = cb_wait_for_future(f);
-    if (ctx.ec()) {
-      cb_throw_error(ctx, "unable to prepend");
+    core::operations::prepend_request req{
+      core::document_id{
+        cb_string_new(bucket),
+        cb_string_new(scope),
+        cb_string_new(collection),
+        cb_string_new(id),
+      },
+    };
+    cb_extract_content(req, content);
+    cb_extract_timeout(req, options);
+    cb_extract_durability_level(req, options);
+    cb_extract_cas(req, options);
+
+    auto parent_span = cb_create_parent_span(req, self);
+
+    std::promise<core::operations::prepend_response> promise;
+    auto f = promise.get_future();
+
+    if (const auto legacy_durability = extract_legacy_durability_constraints(options);
+        legacy_durability.has_value()) {
+      cluster.execute(
+        core::operations::prepend_request_with_legacy_durability{
+          std::move(req),
+          legacy_durability.value().first,
+          legacy_durability.value().second,
+        },
+        [promise = std::move(promise)](auto&& resp) mutable {
+          promise.set_value(std::forward<decltype(resp)>(resp));
+        });
+    } else {
+      cluster.execute(std::move(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 prepend");
     }
 
-    return to_mutation_result_value(resp);
+    return cb_create_mutation_result(resp);
   } catch (const std::system_error& se) {
     rb_exc_raise(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
@@ -728,9 +856,10 @@ cb_Backend_document_replace(VALUE self,
                             VALUE id,
                             VALUE content,
                             VALUE flags,
-                            VALUE options)
+                            VALUE options,
+                            VALUE observability_handler)
 {
-  auto cluster = cb_backend_to_public_api_cluster(self);
+  auto cluster = cb_backend_to_core_api_cluster(self);
 
   Check_Type(bucket, T_STRING);
   Check_Type(scope, T_STRING);
@@ -743,26 +872,51 @@ cb_Backend_document_replace(VALUE self,
   }
 
   try {
-    couchbase::replace_options opts;
-    set_timeout(opts, options);
-    set_expiry(opts, options);
-    set_durability(opts, options);
-    set_preserve_expiry(opts, options);
-    set_cas(opts, options);
-
-    auto f = cluster.bucket(cb_string_new(bucket))
-               .scope(cb_string_new(scope))
-               .collection(cb_string_new(collection))
-               .replace(cb_string_new(id),
-                        couchbase::codec::encoded_value{ cb_binary_new(content), FIX2UINT(flags) },
-                        opts);
-
-    auto [ctx, resp] = cb_wait_for_future(f);
-    if (ctx.ec()) {
-      cb_throw_error(ctx, "unable to replace");
+    core::operations::replace_request req{
+      core::document_id{
+        cb_string_new(bucket),
+        cb_string_new(scope),
+        cb_string_new(collection),
+        cb_string_new(id),
+      },
+    };
+    cb_extract_content(req, content);
+    cb_extract_flags(req, flags);
+    cb_extract_timeout(req, options);
+    cb_extract_expiry(req, options);
+    cb_extract_durability_level(req, options);
+    cb_extract_preserve_expiry(req, options);
+    cb_extract_cas(req, options);
+
+    auto parent_span = cb_create_parent_span(req, self);
+
+    std::promise<core::operations::replace_response> promise;
+    auto f = promise.get_future();
+
+    if (const auto legacy_durability = extract_legacy_durability_constraints(options);
+        legacy_durability.has_value()) {
+      cluster.execute(
+        core::operations::replace_request_with_legacy_durability{
+          std::move(req),
+          legacy_durability.value().first,
+          legacy_durability.value().second,
+        },
+        [promise = std::move(promise)](auto&& resp) mutable {
+          promise.set_value(std::forward<decltype(resp)>(resp));
+        });
+    } else {
+      cluster.execute(std::move(req), [promise = std::move(promise)](auto&& resp) mutable {
+        promise.set_value(std::forward<decltype(resp)>(resp));
+      });
     }
 
-    return to_mutation_result_value(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 replace");
+    }
+    return cb_create_mutation_result(resp);
+
   } catch (const std::system_error& se) {
     rb_exc_raise(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
@@ -780,9 +934,10 @@ cb_Backend_document_insert(VALUE self,
                            VALUE id,
                            VALUE content,
                            VALUE flags,
-                           VALUE options)
+                           VALUE options,
+                           VALUE observability_handler)
 {
-  auto cluster = cb_backend_to_public_api_cluster(self);
+  auto cluster = cb_backend_to_core_api_cluster(self);
 
   Check_Type(bucket, T_STRING);
   Check_Type(scope, T_STRING);
@@ -795,24 +950,48 @@ cb_Backend_document_insert(VALUE self,
   }
 
   try {
-    couchbase::insert_options opts;
-    set_timeout(opts, options);
-    set_expiry(opts, options);
-    set_durability(opts, options);
-
-    auto f = cluster.bucket(cb_string_new(bucket))
-               .scope(cb_string_new(scope))
-               .collection(cb_string_new(collection))
-               .insert(cb_string_new(id),
-                       couchbase::codec::encoded_value{ cb_binary_new(content), FIX2UINT(flags) },
-                       opts);
-
-    auto [ctx, resp] = cb_wait_for_future(f);
-    if (ctx.ec()) {
-      cb_throw_error(ctx, "unable to insert");
+    core::operations::insert_request req{
+      core::document_id{
+        cb_string_new(bucket),
+        cb_string_new(scope),
+        cb_string_new(collection),
+        cb_string_new(id),
+      },
+    };
+    cb_extract_content(req, content);
+    cb_extract_flags(req, flags);
+    cb_extract_timeout(req, options);
+    cb_extract_expiry(req, options);
+    cb_extract_durability_level(req, options);
+
+    auto parent_span = cb_create_parent_span(req, self);
+
+    std::promise<core::operations::insert_response> promise;
+    auto f = promise.get_future();
+
+    if (const auto legacy_durability = extract_legacy_durability_constraints(options);
+        legacy_durability.has_value()) {
+      cluster.execute(
+        core::operations::insert_request_with_legacy_durability{
+          std::move(req),
+          legacy_durability.value().first,
+          legacy_durability.value().second,
+        },
+        [promise = std::move(promise)](auto&& resp) mutable {
+          promise.set_value(std::forward<decltype(resp)>(resp));
+        });
+    } else {
+      cluster.execute(std::move(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 insert");
     }
+    return cb_create_mutation_result(resp);
 
-    return to_mutation_result_value(resp);
   } catch (const std::system_error& se) {
     rb_exc_raise(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
@@ -828,9 +1007,10 @@ cb_Backend_document_remove(VALUE self,
                            VALUE scope,
                            VALUE collection,
                            VALUE id,
-                           VALUE options)
+                           VALUE options,
+                           VALUE observability_handler)
 {
-  auto cluster = cb_backend_to_public_api_cluster(self);
+  auto cluster = cb_backend_to_core_api_cluster(self);
 
   Check_Type(bucket, T_STRING);
   Check_Type(scope, T_STRING);
@@ -841,22 +1021,46 @@ cb_Backend_document_remove(VALUE self,
   }
 
   try {
-    couchbase::remove_options opts;
-    set_timeout(opts, options);
-    set_durability(opts, options);
-    set_cas(opts, options);
-
-    auto f = cluster.bucket(cb_string_new(bucket))
-               .scope(cb_string_new(scope))
-               .collection(cb_string_new(collection))
-               .remove(cb_string_new(id), opts);
-
-    auto [ctx, resp] = cb_wait_for_future(f);
-    if (ctx.ec()) {
-      cb_throw_error(ctx, "unable to remove");
+    core::operations::remove_request req{
+      core::document_id{
+        cb_string_new(bucket),
+        cb_string_new(scope),
+        cb_string_new(collection),
+        cb_string_new(id),
+      },
+    };
+    cb_extract_timeout(req, options);
+    cb_extract_durability_level(req, options);
+    cb_extract_cas(req, options);
+
+    auto parent_span = cb_create_parent_span(req, self);
+
+    std::promise<core::operations::remove_response> promise;
+    auto f = promise.get_future();
+
+    if (const auto legacy_durability = extract_legacy_durability_constraints(options);
+        legacy_durability.has_value()) {
+      cluster.execute(
+        core::operations::remove_request_with_legacy_durability{
+          std::move(req),
+          legacy_durability.value().first,
+          legacy_durability.value().second,
+        },
+        [promise = std::move(promise)](auto&& resp) mutable {
+          promise.set_value(std::forward<decltype(resp)>(resp));
+        });
+    } else {
+      cluster.execute(std::move(req), [promise = std::move(promise)](auto&& resp) mutable {
+        promise.set_value(std::forward<decltype(resp)>(resp));
+      });
     }
 
-    return to_mutation_result_value(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 remove");
+    }
+    return cb_create_mutation_result(resp);
   } catch (const std::system_error& se) {
     rb_exc_raise(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
@@ -872,9 +1076,10 @@ cb_Backend_document_increment(VALUE self,
                               VALUE scope,
                               VALUE collection,
                               VALUE id,
-                              VALUE options)
+                              VALUE options,
+                              VALUE observability_handler)
 {
-  auto cluster = cb_backend_to_public_api_cluster(self);
+  auto cluster = cb_backend_to_core_api_cluster(self);
 
   Check_Type(bucket, T_STRING);
   Check_Type(scope, T_STRING);
@@ -885,27 +1090,53 @@ cb_Backend_document_increment(VALUE self,
   }
 
   try {
-    couchbase::increment_options opts;
-    set_timeout(opts, options);
-    set_durability(opts, options);
-    set_expiry(opts, options);
-    set_delta(opts, options);
-    set_initial_value(opts, options);
-
-    auto f = cluster.bucket(cb_string_new(bucket))
-               .scope(cb_string_new(scope))
-               .collection(cb_string_new(collection))
-               .binary()
-               .increment(cb_string_new(id), opts);
-
-    auto [ctx, resp] = cb_wait_for_future(f);
-    if (ctx.ec()) {
-      cb_throw_error(ctx, "unable to increment");
+    core::operations::increment_request req{
+      core::document_id{
+        cb_string_new(bucket),
+        cb_string_new(scope),
+        cb_string_new(collection),
+        cb_string_new(id),
+      },
+    };
+
+    cb_extract_timeout(req, options);
+    cb_extract_expiry(req, options);
+    cb_extract_option_uint64(req.delta, options, "delta");
+    cb_extract_option_uint64(req.initial_value, options, "initial_value");
+    cb_extract_durability_level(req, options);
+
+    auto parent_span = cb_create_parent_span(req, self);
+
+    std::promise<core::operations::increment_response> promise;
+    auto f = promise.get_future();
+
+    if (const auto legacy_durability = extract_legacy_durability_constraints(options);
+        legacy_durability.has_value()) {
+      cluster.execute(
+        core::operations::increment_request_with_legacy_durability{
+          std::move(req),
+          legacy_durability.value().first,
+          legacy_durability.value().second,
+        },
+        [promise = std::move(promise)](auto&& resp) mutable {
+          promise.set_value(std::forward<decltype(resp)>(resp));
+        });
+    } else {
+      cluster.execute(std::move(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 increment");
     }
 
-    VALUE res = to_mutation_result_value(resp);
-    rb_hash_aset(res, rb_id2sym(rb_intern("content")), ULL2NUM(resp.content()));
+    VALUE res = cb_create_mutation_result(resp);
+    rb_hash_aset(res, rb_id2sym(rb_intern("content")), ULL2NUM(resp.content));
     return res;
+
   } catch (const std::system_error& se) {
     rb_exc_raise(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
@@ -921,9 +1152,10 @@ cb_Backend_document_decrement(VALUE self,
                               VALUE scope,
                               VALUE collection,
                               VALUE id,
-                              VALUE options)
+                              VALUE options,
+                              VALUE observability_handler)
 {
-  auto cluster = cb_backend_to_public_api_cluster(self);
+  auto cluster = cb_backend_to_core_api_cluster(self);
 
   Check_Type(bucket, T_STRING);
   Check_Type(scope, T_STRING);
@@ -934,26 +1166,51 @@ cb_Backend_document_decrement(VALUE self,
   }
 
   try {
-    couchbase::decrement_options opts;
-    set_timeout(opts, options);
-    set_durability(opts, options);
-    set_expiry(opts, options);
-    set_delta(opts, options);
-    set_initial_value(opts, options);
-
-    auto f = cluster.bucket(cb_string_new(bucket))
-               .scope(cb_string_new(scope))
-               .collection(cb_string_new(collection))
-               .binary()
-               .decrement(cb_string_new(id), opts);
-
-    auto [ctx, resp] = cb_wait_for_future(f);
-    if (ctx.ec()) {
-      cb_throw_error(ctx, "unable to decrement");
+    core::operations::decrement_request req{
+      core::document_id{
+        cb_string_new(bucket),
+        cb_string_new(scope),
+        cb_string_new(collection),
+        cb_string_new(id),
+      },
+    };
+
+    cb_extract_timeout(req, options);
+    cb_extract_expiry(req, options);
+    cb_extract_option_uint64(req.delta, options, "delta");
+    cb_extract_option_uint64(req.initial_value, options, "initial_value");
+    cb_extract_durability_level(req, options);
+
+    auto parent_span = cb_create_parent_span(req, self);
+
+    std::promise<core::operations::decrement_response> promise;
+    auto f = promise.get_future();
+
+    if (const auto legacy_durability = extract_legacy_durability_constraints(options);
+        legacy_durability.has_value()) {
+      cluster.execute(
+        core::operations::decrement_request_with_legacy_durability{
+          std::move(req),
+          legacy_durability.value().first,
+          legacy_durability.value().second,
+        },
+        [promise = std::move(promise)](auto&& resp) mutable {
+          promise.set_value(std::forward<decltype(resp)>(resp));
+        });
+    } else {
+      cluster.execute(std::move(req), [promise = std::move(promise)](auto&& resp) mutable {
+        promise.set_value(std::forward<decltype(resp)>(resp));
+      });
     }
 
-    VALUE res = to_mutation_result_value(resp);
-    rb_hash_aset(res, rb_id2sym(rb_intern("content")), ULL2NUM(resp.content()));
+    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 decrement");
+    }
+
+    VALUE res = cb_create_mutation_result(resp);
+    rb_hash_aset(res, rb_id2sym(rb_intern("content")), ULL2NUM(resp.content));
     return res;
 
   } catch (const std::system_error& se) {
@@ -972,7 +1229,8 @@ cb_Backend_document_lookup_in(VALUE self,
                               VALUE collection,
                               VALUE id,
                               VALUE specs,
-                              VALUE options)
+                              VALUE options,
+                              VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -1037,12 +1295,15 @@ cb_Backend_document_lookup_in(VALUE self,
         core::impl::subdoc::build_lookup_in_path_flags(xattr, false) });
     }
 
+    auto parent_span = cb_create_parent_span(req, self);
+
     std::promise<core::operations::lookup_in_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 perform lookup_in operation");
     }
@@ -1098,7 +1359,8 @@ cb_Backend_document_lookup_in_any_replica(VALUE self,
                                           VALUE collection,
                                           VALUE id,
                                           VALUE specs,
-                                          VALUE options)
+                                          VALUE options,
+                                          VALUE observability_handler)
 {
 
   auto cluster = cb_backend_to_core_api_cluster(self);
@@ -1163,12 +1425,15 @@ cb_Backend_document_lookup_in_any_replica(VALUE self,
         core::impl::subdoc::build_lookup_in_path_flags(xattr, false) });
     }
 
+    auto parent_span = cb_create_parent_span(req, self);
+
     std::promise<core::operations::lookup_in_any_replica_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 perform lookup_in_any_replica operation");
     }
@@ -1227,7 +1492,8 @@ cb_Backend_document_lookup_in_all_replicas(VALUE self,
                                            VALUE collection,
                                            VALUE id,
                                            VALUE specs,
-                                           VALUE options)
+                                           VALUE options,
+                                           VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -1292,12 +1558,16 @@ cb_Backend_document_lookup_in_all_replicas(VALUE self,
         {},
         core::impl::subdoc::build_lookup_in_path_flags(xattr, false) });
     }
+
+    auto parent_span = cb_create_parent_span(req, self);
+
     std::promise<core::operations::lookup_in_all_replicas_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 perform lookup_in_all_replicas operation");
     }
@@ -1365,9 +1635,10 @@ cb_Backend_document_mutate_in(VALUE self,
                               VALUE collection,
                               VALUE id,
                               VALUE specs,
-                              VALUE options)
+                              VALUE options,
+                              VALUE observability_handler)
 {
-  auto cluster = cb_backend_to_public_api_cluster(self);
+  auto cluster = cb_backend_to_core_api_cluster(self);
 
   Check_Type(bucket, T_STRING);
   Check_Type(scope, T_STRING);
@@ -1384,15 +1655,22 @@ cb_Backend_document_mutate_in(VALUE self,
   }
 
   try {
-    couchbase::mutate_in_options opts;
-    set_timeout(opts, options);
-    set_durability(opts, options);
-    set_expiry(opts, options);
-    set_preserve_expiry(opts, options);
-    set_access_deleted(opts, options);
-    set_create_as_deleted(opts, options);
-    set_cas(opts, options);
-    set_store_semantics(opts, options);
+    core::operations::mutate_in_request req{
+      core::document_id{
+        cb_string_new(bucket),
+        cb_string_new(scope),
+        cb_string_new(collection),
+        cb_string_new(id),
+      },
+    };
+    cb_extract_timeout(req, options);
+    cb_extract_durability_level(req, options);
+    cb_extract_expiry(req, options);
+    cb_extract_preserve_expiry(req, options);
+    cb_extract_option_bool(req.access_deleted, options, "access_deleted");
+    cb_extract_option_bool(req.create_as_deleted, options, "create_as_deleted");
+    cb_extract_cas(req, options);
+    cb_extract_store_semantics(req, options);
 
     static VALUE xattr_property = rb_id2sym(rb_intern("xattr"));
     static VALUE create_path_property = rb_id2sym(rb_intern("create_path"));
@@ -1402,130 +1680,147 @@ cb_Backend_document_mutate_in(VALUE self,
     static VALUE param_property = rb_id2sym(rb_intern("param"));
 
     couchbase::mutate_in_specs cxx_specs;
-    auto entries_size = static_cast<std::size_t>(RARRAY_LEN(specs));
-    for (std::size_t i = 0; i < entries_size; ++i) {
-      VALUE entry = rb_ary_entry(specs, static_cast<long>(i));
-      cb_check_type(entry, T_HASH);
-      bool xattr = RTEST(rb_hash_aref(entry, xattr_property));
-      bool create_path = RTEST(rb_hash_aref(entry, create_path_property));
-      bool expand_macros = RTEST(rb_hash_aref(entry, expand_macros_property));
-      VALUE path = rb_hash_aref(entry, path_property);
-      cb_check_type(path, T_STRING);
-      VALUE operation = rb_hash_aref(entry, opcode_property);
-      cb_check_type(operation, T_SYMBOL);
-      VALUE param = rb_hash_aref(entry, param_property);
-      if (ID operation_id = rb_sym2id(operation); operation_id == rb_intern("dict_add")) {
-        cb_check_type(param, T_STRING);
-        cxx_specs.push_back(couchbase::mutate_in_specs::insert_raw(
-                              cb_string_new(path), cb_binary_new(param), expand_macros)
-                              .xattr(xattr)
-                              .create_path(create_path));
-      } else if (operation_id == rb_intern("dict_upsert")) {
-        cb_check_type(param, T_STRING);
-
-        cxx_specs.push_back(couchbase::mutate_in_specs::upsert_raw(
-                              cb_string_new(path), cb_binary_new(param), expand_macros)
-                              .xattr(xattr)
-                              .create_path(create_path));
-      } else if (operation_id == rb_intern("remove")) {
-        cxx_specs.push_back(couchbase::mutate_in_specs::remove(cb_string_new(path)).xattr(xattr));
-      } else if (operation_id == rb_intern("replace")) {
-        cb_check_type(param, T_STRING);
-        cxx_specs.push_back(couchbase::mutate_in_specs::replace_raw(
-                              cb_string_new(path), cb_binary_new(param), expand_macros)
-                              .xattr(xattr));
-      } else if (operation_id == rb_intern("array_push_last")) {
-        cb_check_type(param, T_STRING);
-        cxx_specs.push_back(
-          couchbase::mutate_in_specs::array_append_raw(cb_string_new(path), cb_binary_new(param))
-            .xattr(xattr)
-            .create_path(create_path));
-      } else if (operation_id == rb_intern("array_push_first")) {
-        cb_check_type(param, T_STRING);
-        cxx_specs.push_back(
-          couchbase::mutate_in_specs::array_prepend_raw(cb_string_new(path), cb_binary_new(param))
-            .xattr(xattr)
-            .create_path(create_path));
-      } else if (operation_id == rb_intern("array_insert")) {
-        cb_check_type(param, T_STRING);
-        cxx_specs.push_back(
-          couchbase::mutate_in_specs::array_insert_raw(cb_string_new(path), cb_binary_new(param))
-            .xattr(xattr)
-            .create_path(create_path));
-      } else if (operation_id == rb_intern("array_add_unique")) {
-        cb_check_type(param, T_STRING);
-        cxx_specs.push_back(couchbase::mutate_in_specs::array_add_unique_raw(
-                              cb_string_new(path), cb_binary_new(param), expand_macros)
-                              .xattr(xattr)
-                              .create_path(create_path));
-      } else if (operation_id == rb_intern("counter")) {
-        if (TYPE(param) == T_FIXNUM || TYPE(param) == T_BIGNUM) {
-          if (std::int64_t num = NUM2LL(param); num < 0) {
-            cxx_specs.push_back(couchbase::mutate_in_specs::decrement(cb_string_new(path), -1 * num)
-                                  .xattr(xattr)
-                                  .create_path(create_path));
+    {
+      auto entries_size = static_cast<std::size_t>(RARRAY_LEN(specs));
+      for (std::size_t i = 0; i < entries_size; ++i) {
+        VALUE entry = rb_ary_entry(specs, static_cast<long>(i));
+        cb_check_type(entry, T_HASH);
+        bool xattr = RTEST(rb_hash_aref(entry, xattr_property));
+        bool create_path = RTEST(rb_hash_aref(entry, create_path_property));
+        bool expand_macros = RTEST(rb_hash_aref(entry, expand_macros_property));
+        VALUE path = rb_hash_aref(entry, path_property);
+        cb_check_type(path, T_STRING);
+        VALUE operation = rb_hash_aref(entry, opcode_property);
+        cb_check_type(operation, T_SYMBOL);
+        VALUE param = rb_hash_aref(entry, param_property);
+        if (ID operation_id = rb_sym2id(operation); operation_id == rb_intern("dict_add")) {
+          cb_check_type(param, T_STRING);
+          cxx_specs.push_back(couchbase::mutate_in_specs::insert_raw(
+                                cb_string_new(path), cb_binary_new(param), expand_macros)
+                                .xattr(xattr)
+                                .create_path(create_path));
+        } else if (operation_id == rb_intern("dict_upsert")) {
+          cb_check_type(param, T_STRING);
+
+          cxx_specs.push_back(couchbase::mutate_in_specs::upsert_raw(
+                                cb_string_new(path), cb_binary_new(param), expand_macros)
+                                .xattr(xattr)
+                                .create_path(create_path));
+        } else if (operation_id == rb_intern("remove")) {
+          cxx_specs.push_back(couchbase::mutate_in_specs::remove(cb_string_new(path)).xattr(xattr));
+        } else if (operation_id == rb_intern("replace")) {
+          cb_check_type(param, T_STRING);
+          cxx_specs.push_back(couchbase::mutate_in_specs::replace_raw(
+                                cb_string_new(path), cb_binary_new(param), expand_macros)
+                                .xattr(xattr));
+        } else if (operation_id == rb_intern("array_push_last")) {
+          cb_check_type(param, T_STRING);
+          cxx_specs.push_back(
+            couchbase::mutate_in_specs::array_append_raw(cb_string_new(path), cb_binary_new(param))
+              .xattr(xattr)
+              .create_path(create_path));
+        } else if (operation_id == rb_intern("array_push_first")) {
+          cb_check_type(param, T_STRING);
+          cxx_specs.push_back(
+            couchbase::mutate_in_specs::array_prepend_raw(cb_string_new(path), cb_binary_new(param))
+              .xattr(xattr)
+              .create_path(create_path));
+        } else if (operation_id == rb_intern("array_insert")) {
+          cb_check_type(param, T_STRING);
+          cxx_specs.push_back(
+            couchbase::mutate_in_specs::array_insert_raw(cb_string_new(path), cb_binary_new(param))
+              .xattr(xattr)
+              .create_path(create_path));
+        } else if (operation_id == rb_intern("array_add_unique")) {
+          cb_check_type(param, T_STRING);
+          cxx_specs.push_back(couchbase::mutate_in_specs::array_add_unique_raw(
+                                cb_string_new(path), cb_binary_new(param), expand_macros)
+                                .xattr(xattr)
+                                .create_path(create_path));
+        } else if (operation_id == rb_intern("counter")) {
+          if (TYPE(param) == T_FIXNUM || TYPE(param) == T_BIGNUM) {
+            if (std::int64_t num = NUM2LL(param); num < 0) {
+              cxx_specs.push_back(
+                couchbase::mutate_in_specs::decrement(cb_string_new(path), -1 * num)
+                  .xattr(xattr)
+                  .create_path(create_path));
+            } else {
+              cxx_specs.push_back(couchbase::mutate_in_specs::increment(cb_string_new(path), num)
+                                    .xattr(xattr)
+                                    .create_path(create_path));
+            }
           } else {
-            cxx_specs.push_back(couchbase::mutate_in_specs::increment(cb_string_new(path), num)
-                                  .xattr(xattr)
-                                  .create_path(create_path));
+            throw ruby_exception(
+              exc_invalid_argument(),
+              rb_sprintf("subdocument counter operation expects number, but given: %+" PRIsVALUE,
+                         param));
           }
+        } else if (operation_id == rb_intern("set_doc")) {
+          cb_check_type(param, T_STRING);
+          cxx_specs.push_back(
+            couchbase::mutate_in_specs::replace_raw("", cb_binary_new(param), expand_macros)
+              .xattr(xattr));
+        } else if (operation_id == rb_intern("remove_doc")) {
+          cxx_specs.push_back(couchbase::mutate_in_specs::remove("").xattr(xattr));
         } else {
           throw ruby_exception(
             exc_invalid_argument(),
-            rb_sprintf("subdocument counter operation expects number, but given: %+" PRIsVALUE,
-                       param));
+            rb_sprintf("unsupported operation for subdocument mutation: %+" PRIsVALUE, operation));
         }
-      } else if (operation_id == rb_intern("set_doc")) {
-        cb_check_type(param, T_STRING);
-        cxx_specs.push_back(
-          couchbase::mutate_in_specs::replace_raw("", cb_binary_new(param), expand_macros)
-            .xattr(xattr));
-      } else if (operation_id == rb_intern("remove_doc")) {
-        cxx_specs.push_back(couchbase::mutate_in_specs::remove("").xattr(xattr));
-      } else {
-        throw ruby_exception(
-          exc_invalid_argument(),
-          rb_sprintf("unsupported operation for subdocument mutation: %+" PRIsVALUE, operation));
       }
     }
+    req.specs = cxx_specs.specs();
 
-    auto f = cluster.bucket(cb_string_new(bucket))
-               .scope(cb_string_new(scope))
-               .collection(cb_string_new(collection))
-               .mutate_in(cb_string_new(id), cxx_specs, opts);
+    auto parent_span = cb_create_parent_span(req, self);
 
-    auto [ctx, resp] = cb_wait_for_future(f);
-    if (ctx.ec()) {
-      cb_throw_error(ctx, "unable to mutate_in");
+    std::promise<core::operations::mutate_in_response> promise;
+    auto f = promise.get_future();
+
+    if (const auto legacy_durability = extract_legacy_durability_constraints(options);
+        legacy_durability.has_value()) {
+      cluster.execute(
+        core::operations::mutate_in_request_with_legacy_durability{
+          std::move(req),
+          legacy_durability.value().first,
+          legacy_durability.value().second,
+        },
+        [promise = std::move(promise)](auto&& resp) mutable {
+          promise.set_value(std::forward<decltype(resp)>(resp));
+        });
+    } else {
+      cluster.execute(std::move(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 mutate_in");
     }
 
     static VALUE deleted_property = rb_id2sym(rb_intern("deleted"));
     static VALUE fields_property = rb_id2sym(rb_intern("fields"));
     static VALUE index_property = rb_id2sym(rb_intern("index"));
-    static VALUE cas_property = rb_id2sym(rb_intern("cas"));
     static VALUE value_property = rb_id2sym(rb_intern("value"));
 
-    VALUE res = to_mutation_result_value(resp);
-    rb_hash_aset(res, deleted_property, resp.is_deleted() ? Qtrue : Qfalse);
-    if (!ctx.ec()) {
-      rb_hash_aset(res, cas_property, cb_cas_to_num(resp.cas()));
-
-      VALUE fields = rb_ary_new_capa(static_cast<long>(entries_size));
-      rb_hash_aset(res, fields_property, fields);
-      for (std::size_t i = 0; i < entries_size; ++i) {
-        VALUE entry = rb_hash_new();
-        rb_hash_aset(entry, index_property, ULL2NUM(i));
-        rb_hash_aset(entry,
-                     path_property,
-                     rb_hash_aref(rb_ary_entry(specs, static_cast<long>(i)), path_property));
-        if (resp.has_value(i)) {
-          auto value = resp.content_as<tao::json::value>(i);
-          rb_hash_aset(entry, value_property, cb_str_new(core::utils::json::generate(value)));
-        }
-        rb_ary_store(fields, static_cast<long>(i), entry);
+    VALUE res = cb_create_mutation_result(resp);
+    rb_hash_aset(res, deleted_property, resp.deleted ? Qtrue : Qfalse);
+    VALUE fields = rb_ary_new_capa(static_cast<long>(resp.fields.size()));
+    rb_hash_aset(res, fields_property, fields);
+    for (std::size_t i = 0; i < resp.fields.size(); ++i) {
+      VALUE entry = rb_hash_new();
+      rb_hash_aset(entry, index_property, ULL2NUM(i));
+      rb_hash_aset(entry,
+                   path_property,
+                   rb_hash_aref(rb_ary_entry(specs, static_cast<long>(i)), path_property));
+      if (!resp.fields.at(i).value.empty()) {
+        rb_hash_aset(entry, value_property, cb_str_new(resp.fields.at(i).value));
       }
+      rb_ary_store(fields, static_cast<long>(i), entry);
     }
     return res;
+
   } catch (const std::system_error& se) {
     rb_exc_raise(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
@@ -1540,28 +1835,28 @@ cb_Backend_document_mutate_in(VALUE self,
 void
 init_crud(VALUE cBackend)
 {
-  rb_define_method(cBackend, "document_get", cb_Backend_document_get, 5);
-  rb_define_method(cBackend, "document_get_any_replica", cb_Backend_document_get_any_replica, 5);
-  rb_define_method(cBackend, "document_get_all_replicas", cb_Backend_document_get_all_replicas, 5);
-  rb_define_method(cBackend, "document_get_projected", cb_Backend_document_get_projected, 5);
-  rb_define_method(cBackend, "document_get_and_lock", cb_Backend_document_get_and_lock, 6);
-  rb_define_method(cBackend, "document_get_and_touch", cb_Backend_document_get_and_touch, 6);
-  rb_define_method(cBackend, "document_insert", cb_Backend_document_insert, 7);
-  rb_define_method(cBackend, "document_replace", cb_Backend_document_replace, 7);
-  rb_define_method(cBackend, "document_upsert", cb_Backend_document_upsert, 7);
-  rb_define_method(cBackend, "document_append", cb_Backend_document_append, 6);
-  rb_define_method(cBackend, "document_prepend", cb_Backend_document_prepend, 6);
-  rb_define_method(cBackend, "document_remove", cb_Backend_document_remove, 5);
-  rb_define_method(cBackend, "document_lookup_in", cb_Backend_document_lookup_in, 6);
+  rb_define_method(cBackend, "document_get", cb_Backend_document_get, 6);
+  rb_define_method(cBackend, "document_get_any_replica", cb_Backend_document_get_any_replica, 6);
+  rb_define_method(cBackend, "document_get_all_replicas", cb_Backend_document_get_all_replicas, 6);
+  rb_define_method(cBackend, "document_get_projected", cb_Backend_document_get_projected, 6);
+  rb_define_method(cBackend, "document_get_and_lock", cb_Backend_document_get_and_lock, 7);
+  rb_define_method(cBackend, "document_get_and_touch", cb_Backend_document_get_and_touch, 7);
+  rb_define_method(cBackend, "document_insert", cb_Backend_document_insert, 8);
+  rb_define_method(cBackend, "document_replace", cb_Backend_document_replace, 8);
+  rb_define_method(cBackend, "document_upsert", cb_Backend_document_upsert, 8);
+  rb_define_method(cBackend, "document_append", cb_Backend_document_append, 7);
+  rb_define_method(cBackend, "document_prepend", cb_Backend_document_prepend, 7);
+  rb_define_method(cBackend, "document_remove", cb_Backend_document_remove, 6);
+  rb_define_method(cBackend, "document_lookup_in", cb_Backend_document_lookup_in, 7);
   rb_define_method(
-    cBackend, "document_lookup_in_any_replica", cb_Backend_document_lookup_in_any_replica, 6);
+    cBackend, "document_lookup_in_any_replica", cb_Backend_document_lookup_in_any_replica, 7);
   rb_define_method(
-    cBackend, "document_lookup_in_all_replicas", cb_Backend_document_lookup_in_all_replicas, 6);
-  rb_define_method(cBackend, "document_mutate_in", cb_Backend_document_mutate_in, 6);
-  rb_define_method(cBackend, "document_touch", cb_Backend_document_touch, 6);
-  rb_define_method(cBackend, "document_exists", cb_Backend_document_exists, 5);
-  rb_define_method(cBackend, "document_unlock", cb_Backend_document_unlock, 6);
-  rb_define_method(cBackend, "document_increment", cb_Backend_document_increment, 5);
-  rb_define_method(cBackend, "document_decrement", cb_Backend_document_decrement, 5);
+    cBackend, "document_lookup_in_all_replicas", cb_Backend_document_lookup_in_all_replicas, 7);
+  rb_define_method(cBackend, "document_mutate_in", cb_Backend_document_mutate_in, 7);
+  rb_define_method(cBackend, "document_touch", cb_Backend_document_touch, 7);
+  rb_define_method(cBackend, "document_exists", cb_Backend_document_exists, 6);
+  rb_define_method(cBackend, "document_unlock", cb_Backend_document_unlock, 7);
+  rb_define_method(cBackend, "document_increment", cb_Backend_document_increment, 6);
+  rb_define_method(cBackend, "document_decrement", cb_Backend_document_decrement, 6);
 }
 } // namespace couchbase::ruby