couchbase 3.4.3 → 3.4.4

data/ext/couchbase.cxx

@@ -33,9 +33,12 @@
 #include <core/platform/terminate_handler.h>
 
 #include <core/cluster.hxx>
+
+#include <core/agent_group.hxx>
 #include <core/design_document_namespace_fmt.hxx>
 #include <core/logger/configuration.hxx>
 #include <core/operations.hxx>
+
 #include <core/operations/management/analytics.hxx>
 #include <core/operations/management/bucket.hxx>
 #include <core/operations/management/cluster_developer_preview_enable.hxx>
@@ -45,6 +48,12 @@
 #include <core/operations/management/user.hxx>
 #include <core/operations/management/view.hxx>
 
+#include <core/impl/subdoc/path_flags.hxx>
+
+#include <core/range_scan_options.hxx>
+#include <core/range_scan_orchestrator.hxx>
+#include <core/range_scan_orchestrator_options.hxx>
+
 #include <core/io/dns_client.hxx>
 #include <core/io/dns_config.hxx>
 #include <core/utils/connection_string.hxx>
@@ -435,7 +444,7 @@ cb_backend_close(cb_backend_data* backend)
 static void
 cb_Backend_mark(void* /* ptr */)
 {
-    /* no embeded ruby objects -- no mark */
+    /* no embedded ruby objects -- no mark */
 }
 
 static void
@@ -495,6 +504,8 @@ cb_backend_to_cluster(VALUE self)
     return backend->cluster;
 }
 
+static VALUE eCouchbaseError;
+
 static VALUE eAmbiguousTimeout;
 static VALUE eAuthenticationFailure;
 static VALUE eBucketExists;
@@ -534,6 +545,7 @@ static VALUE eInvalidArgument;
 static VALUE eJobQueueFull;
 static VALUE eLinkNotFound;
 static VALUE eLinkExists;
+static VALUE eMutationTokenOutdated;
 static VALUE eNumberTooBig;
 static VALUE eParsingFailure;
 static VALUE ePathExists;
@@ -586,7 +598,7 @@ static void
 init_exceptions(VALUE mCouchbase)
 {
     VALUE mError = rb_define_module_under(mCouchbase, "Error");
-    VALUE eCouchbaseError = rb_define_class_under(mError, "CouchbaseError", rb_eStandardError);
+    eCouchbaseError = rb_define_class_under(mError, "CouchbaseError", rb_eStandardError);
 
     VALUE eTimeout = rb_define_class_under(mError, "Timeout", eCouchbaseError);
 
@@ -629,6 +641,7 @@ init_exceptions(VALUE mCouchbase)
     eJobQueueFull = rb_define_class_under(mError, "JobQueueFull", eCouchbaseError);
     eLinkNotFound = rb_define_class_under(mError, "LinkNotFound", eCouchbaseError);
     eLinkExists = rb_define_class_under(mError, "LinkExists", eCouchbaseError);
+    eMutationTokenOutdated = rb_define_class_under(mError, "MutationTokenOutdated", eCouchbaseError);
     eNumberTooBig = rb_define_class_under(mError, "NumberTooBig", eCouchbaseError);
     eParsingFailure = rb_define_class_under(mError, "ParsingFailure", eCouchbaseError);
     ePathExists = rb_define_class_under(mError, "PathExists", eCouchbaseError);
@@ -784,6 +797,9 @@ cb_map_error_code(std::error_code ec, const std::string& message, bool include_e
             case couchbase::errc::key_value::durable_write_re_commit_in_progress:
                 return rb_exc_new_cstr(eDurableWriteReCommitInProgress, what.c_str());
 
+            case couchbase::errc::key_value::mutation_token_outdated:
+                return rb_exc_new_cstr(eMutationTokenOutdated, what.c_str());
+
             case couchbase::errc::key_value::path_not_found:
                 return rb_exc_new_cstr(ePathNotFound, what.c_str());
 
@@ -834,6 +850,10 @@ cb_map_error_code(std::error_code ec, const std::string& message, bool include_e
 
             case couchbase::errc::key_value::cannot_revive_living_document:
                 return rb_exc_new_cstr(eCannotReviveLivingDocument, what.c_str());
+
+            case couchbase::errc::key_value::range_scan_completed:
+                // Should not be exposed to the Ruby SDK, map it to a BackendError
+                return rb_exc_new_cstr(eBackendError, what.c_str());
         }
     } else if (ec.category() == couchbase::core::impl::query_category()) {
         switch (static_cast<couchbase::errc::query>(ec.value())) {
@@ -3409,7 +3429,7 @@ cb_Backend_document_decrement(VALUE self, VALUE bucket, VALUE scope, VALUE colle
 static VALUE
 cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE scope, VALUE collection, VALUE id, VALUE specs, VALUE options)
 {
-    const auto& core = cb_backend_to_cluster(self);
+    const auto& cluster = cb_backend_to_cluster(self);
 
     Check_Type(bucket, T_STRING);
     Check_Type(scope, T_STRING);
@@ -3425,10 +3445,6 @@ cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE scope, VALUE colle
     }
 
     try {
-        couchbase::lookup_in_options opts;
-        couchbase::ruby::set_timeout(opts, options);
-        couchbase::ruby::set_access_deleted(opts, options);
-
         couchbase::core::document_id doc_id{
             cb_string_new(bucket),
             cb_string_new(scope),
@@ -3436,12 +3452,15 @@ cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE scope, VALUE colle
             cb_string_new(id),
         };
 
+        couchbase::core::operations::lookup_in_request req{ doc_id };
+        cb_extract_timeout(req, options);
+        cb_extract_option_bool(req.access_deleted, options, "access_deleted");
+
         static VALUE xattr_property = rb_id2sym(rb_intern("xattr"));
         static VALUE path_property = rb_id2sym(rb_intern("path"));
         static VALUE opcode_property = rb_id2sym(rb_intern("opcode"));
 
         auto entries_size = static_cast<std::size_t>(RARRAY_LEN(specs));
-        couchbase::lookup_in_specs cxx_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);
@@ -3450,29 +3469,138 @@ cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE scope, VALUE colle
             bool xattr = RTEST(rb_hash_aref(entry, xattr_property));
             VALUE path = rb_hash_aref(entry, path_property);
             cb_check_type(path, T_STRING);
+            auto opcode = couchbase::core::impl::subdoc::opcode{};
             if (ID operation_id = rb_sym2id(operation); operation_id == rb_intern("get_doc")) {
-                cxx_specs.push_back(couchbase::lookup_in_specs::get("").xattr(xattr));
+                opcode = couchbase::core::impl::subdoc::opcode::get_doc;
             } else if (operation_id == rb_intern("get")) {
-                cxx_specs.push_back(couchbase::lookup_in_specs::get(cb_string_new(path)).xattr(xattr));
+                opcode = couchbase::core::impl::subdoc::opcode::get;
             } else if (operation_id == rb_intern("exists")) {
-                cxx_specs.push_back(couchbase::lookup_in_specs::exists(cb_string_new(path)).xattr(xattr));
+                opcode = couchbase::core::impl::subdoc::opcode::exists;
             } else if (operation_id == rb_intern("count")) {
-                cxx_specs.push_back(couchbase::lookup_in_specs::count(cb_string_new(path)).xattr(xattr));
+                opcode = couchbase::core::impl::subdoc::opcode::get_count;
             } else {
                 throw ruby_exception(eInvalidArgument, rb_sprintf("unsupported operation for subdocument lookup: %+" PRIsVALUE, operation));
             }
             cb_check_type(path, T_STRING);
+
+            req.specs.emplace_back(couchbase::core::impl::subdoc::command{
+              opcode, cb_string_new(path), {}, couchbase::core::impl::subdoc::build_lookup_in_path_flags(xattr) });
         }
 
-        auto f = couchbase::cluster(core)
-                   .bucket(cb_string_new(bucket))
-                   .scope(cb_string_new(scope))
-                   .collection(cb_string_new(collection))
-                   .lookup_in(cb_string_new(id), cxx_specs, opts);
+        auto barrier = std::make_shared<std::promise<couchbase::core::operations::lookup_in_response>>();
+        auto f = barrier->get_future();
+        cluster->execute(req, [barrier](couchbase::core::operations::lookup_in_response&& resp) { barrier->set_value(std::move(resp)); });
+        auto resp = cb_wait_for_future(f);
+        if (resp.ctx.ec()) {
+            cb_throw_error_code(resp.ctx, "unable to perform lookup_in operation");
+        }
 
-        auto [ctx, resp] = cb_wait_for_future(f);
-        if (ctx.ec()) {
-            cb_throw_error_code(ctx, "unable to lookup_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 exists_property = rb_id2sym(rb_intern("exists"));
+        static VALUE cas_property = rb_id2sym(rb_intern("cas"));
+        static VALUE value_property = rb_id2sym(rb_intern("value"));
+        static VALUE error_property = rb_id2sym(rb_intern("error"));
+
+        VALUE res = rb_hash_new();
+        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);
+        rb_hash_aset(res, deleted_property, resp.deleted ? Qtrue : Qfalse);
+        for (std::size_t i = 0; i < entries_size; ++i) {
+            auto resp_entry = resp.fields.at(i);
+            VALUE entry = rb_hash_new();
+            rb_hash_aset(entry, index_property, ULL2NUM(resp_entry.original_index));
+            rb_hash_aset(entry, exists_property, resp_entry.exists ? Qtrue : Qfalse);
+            rb_hash_aset(entry, path_property, cb_str_new(resp_entry.path));
+            if (!resp_entry.value.empty()) {
+                rb_hash_aset(entry, value_property, cb_str_new(resp_entry.value));
+            }
+            if (resp_entry.ec && resp_entry.ec != couchbase::errc::key_value::path_not_found) {
+                rb_hash_aset(entry,
+                             error_property,
+                             cb_map_error_code(resp_entry.ec,
+                                               fmt::format("error getting result for spec at index {}, path \"{}\"", i, resp_entry.path)));
+            }
+            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));
+    } catch (const ruby_exception& e) {
+        rb_exc_raise(e.exception_object());
+    }
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_document_lookup_in_any_replica(VALUE self, VALUE bucket, VALUE scope, VALUE collection, VALUE id, VALUE specs, VALUE options)
+{
+    const auto& cluster = cb_backend_to_cluster(self);
+
+    Check_Type(bucket, T_STRING);
+    Check_Type(scope, T_STRING);
+    Check_Type(collection, T_STRING);
+    Check_Type(id, T_STRING);
+    Check_Type(specs, T_ARRAY);
+    if (RARRAY_LEN(specs) <= 0) {
+        rb_raise(rb_eArgError, "Array with specs cannot be empty");
+        return Qnil;
+    }
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
+
+    try {
+        couchbase::core::document_id doc_id{
+            cb_string_new(bucket),
+            cb_string_new(scope),
+            cb_string_new(collection),
+            cb_string_new(id),
+        };
+
+        couchbase::core::operations::lookup_in_any_replica_request req{ doc_id };
+        cb_extract_timeout(req, options);
+
+        static VALUE xattr_property = rb_id2sym(rb_intern("xattr"));
+        static VALUE path_property = rb_id2sym(rb_intern("path"));
+        static VALUE opcode_property = rb_id2sym(rb_intern("opcode"));
+
+        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);
+            VALUE operation = rb_hash_aref(entry, opcode_property);
+            cb_check_type(operation, T_SYMBOL);
+            bool xattr = RTEST(rb_hash_aref(entry, xattr_property));
+            VALUE path = rb_hash_aref(entry, path_property);
+            cb_check_type(path, T_STRING);
+            auto opcode = couchbase::core::impl::subdoc::opcode{};
+            if (ID operation_id = rb_sym2id(operation); operation_id == rb_intern("get_doc")) {
+                opcode = couchbase::core::impl::subdoc::opcode::get_doc;
+            } else if (operation_id == rb_intern("get")) {
+                opcode = couchbase::core::impl::subdoc::opcode::get;
+            } else if (operation_id == rb_intern("exists")) {
+                opcode = couchbase::core::impl::subdoc::opcode::exists;
+            } else if (operation_id == rb_intern("count")) {
+                opcode = couchbase::core::impl::subdoc::opcode::get_count;
+            } else {
+                throw ruby_exception(eInvalidArgument, rb_sprintf("unsupported operation for subdocument lookup: %+" PRIsVALUE, operation));
+            }
+            cb_check_type(path, T_STRING);
+
+            req.specs.emplace_back(couchbase::core::impl::subdoc::command{
+              opcode, cb_string_new(path), {}, couchbase::core::impl::subdoc::build_lookup_in_path_flags(xattr) });
+        }
+
+        auto barrier = std::make_shared<std::promise<couchbase::core::operations::lookup_in_any_replica_response>>();
+        auto f = barrier->get_future();
+        cluster->execute(
+          req, [barrier](couchbase::core::operations::lookup_in_any_replica_response&& resp) { barrier->set_value(std::move(resp)); });
+        auto resp = cb_wait_for_future(f);
+        if (resp.ctx.ec()) {
+            cb_throw_error_code(resp.ctx, "unable to perform lookup_in_any_replica operation");
         }
 
         static VALUE deleted_property = rb_id2sym(rb_intern("deleted"));
@@ -3481,23 +3609,153 @@ cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE scope, VALUE colle
         static VALUE exists_property = rb_id2sym(rb_intern("exists"));
         static VALUE cas_property = rb_id2sym(rb_intern("cas"));
         static VALUE value_property = rb_id2sym(rb_intern("value"));
+        static VALUE error_property = rb_id2sym(rb_intern("error"));
+        static VALUE is_replica_property = rb_id2sym(rb_intern("is_replica"));
 
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, cas_property, cb_cas_to_num(resp.cas()));
+        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);
-        rb_hash_aset(res, deleted_property, resp.is_deleted() ? Qtrue : Qfalse);
+        rb_hash_aset(res, deleted_property, resp.deleted ? Qtrue : Qfalse);
+        rb_hash_aset(res, is_replica_property, resp.is_replica ? Qtrue : Qfalse);
+
         for (std::size_t i = 0; i < entries_size; ++i) {
+            auto resp_entry = resp.fields.at(i);
             VALUE entry = rb_hash_new();
-            rb_hash_aset(entry, index_property, ULL2NUM(i));
-            rb_hash_aset(entry, exists_property, resp.exists(i) ? Qtrue : Qfalse);
-            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(couchbase::core::utils::json::generate(value)));
+            rb_hash_aset(entry, index_property, ULL2NUM(resp_entry.original_index));
+            rb_hash_aset(entry, exists_property, resp_entry.exists ? Qtrue : Qfalse);
+            rb_hash_aset(entry, path_property, cb_str_new(resp_entry.path));
+            if (!resp_entry.value.empty()) {
+                rb_hash_aset(entry, value_property, cb_str_new(resp_entry.value));
+            }
+            if (resp_entry.ec && resp_entry.ec != couchbase::errc::key_value::path_not_found) {
+                rb_hash_aset(entry,
+                             error_property,
+                             cb_map_error_code(resp_entry.ec,
+                                               fmt::format("error getting result for spec at index {}, path \"{}\"", i, resp_entry.path)));
             }
             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));
+    } catch (const ruby_exception& e) {
+        rb_exc_raise(e.exception_object());
+    }
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_document_lookup_in_all_replicas(VALUE self, VALUE bucket, VALUE scope, VALUE collection, VALUE id, VALUE specs, VALUE options)
+{
+    const auto& cluster = cb_backend_to_cluster(self);
+
+    Check_Type(bucket, T_STRING);
+    Check_Type(scope, T_STRING);
+    Check_Type(collection, T_STRING);
+    Check_Type(id, T_STRING);
+    Check_Type(specs, T_ARRAY);
+    if (RARRAY_LEN(specs) <= 0) {
+        rb_raise(rb_eArgError, "Array with specs cannot be empty");
+        return Qnil;
+    }
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
+
+    try {
+        couchbase::core::document_id doc_id{
+            cb_string_new(bucket),
+            cb_string_new(scope),
+            cb_string_new(collection),
+            cb_string_new(id),
+        };
+
+        couchbase::core::operations::lookup_in_all_replicas_request req{ doc_id };
+        cb_extract_timeout(req, options);
+
+        static VALUE xattr_property = rb_id2sym(rb_intern("xattr"));
+        static VALUE path_property = rb_id2sym(rb_intern("path"));
+        static VALUE opcode_property = rb_id2sym(rb_intern("opcode"));
+
+        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);
+            VALUE operation = rb_hash_aref(entry, opcode_property);
+            cb_check_type(operation, T_SYMBOL);
+            bool xattr = RTEST(rb_hash_aref(entry, xattr_property));
+            VALUE path = rb_hash_aref(entry, path_property);
+            cb_check_type(path, T_STRING);
+            auto opcode = couchbase::core::impl::subdoc::opcode{};
+            if (ID operation_id = rb_sym2id(operation); operation_id == rb_intern("get_doc")) {
+                opcode = couchbase::core::impl::subdoc::opcode::get_doc;
+            } else if (operation_id == rb_intern("get")) {
+                opcode = couchbase::core::impl::subdoc::opcode::get;
+            } else if (operation_id == rb_intern("exists")) {
+                opcode = couchbase::core::impl::subdoc::opcode::exists;
+            } else if (operation_id == rb_intern("count")) {
+                opcode = couchbase::core::impl::subdoc::opcode::get_count;
+            } else {
+                throw ruby_exception(eInvalidArgument, rb_sprintf("unsupported operation for subdocument lookup: %+" PRIsVALUE, operation));
+            }
+            cb_check_type(path, T_STRING);
+
+            req.specs.emplace_back(couchbase::core::impl::subdoc::command{
+              opcode, cb_string_new(path), {}, couchbase::core::impl::subdoc::build_lookup_in_path_flags(xattr) });
+        }
+
+        auto barrier = std::make_shared<std::promise<couchbase::core::operations::lookup_in_all_replicas_response>>();
+        auto f = barrier->get_future();
+        cluster->execute(
+          req, [barrier](couchbase::core::operations::lookup_in_all_replicas_response&& resp) { barrier->set_value(std::move(resp)); });
+        auto resp = cb_wait_for_future(f);
+        if (resp.ctx.ec()) {
+            cb_throw_error_code(resp.ctx, "unable to perform lookup_in_all_replicas operation");
+        }
+
+        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 exists_property = rb_id2sym(rb_intern("exists"));
+        static VALUE cas_property = rb_id2sym(rb_intern("cas"));
+        static VALUE value_property = rb_id2sym(rb_intern("value"));
+        static VALUE error_property = rb_id2sym(rb_intern("error"));
+        static VALUE is_replica_property = rb_id2sym(rb_intern("is_replica"));
+
+        auto lookup_in_entries_size = resp.entries.size();
+        VALUE res = rb_ary_new_capa(static_cast<long>(lookup_in_entries_size));
+        for (std::size_t j = 0; j < lookup_in_entries_size; ++j) {
+            auto lookup_in_entry = resp.entries.at(j);
+            VALUE lookup_in_entry_res = rb_hash_new();
+            rb_hash_aset(lookup_in_entry_res, cas_property, cb_cas_to_num(lookup_in_entry.cas));
+            VALUE fields = rb_ary_new_capa(static_cast<long>(entries_size));
+            rb_hash_aset(lookup_in_entry_res, fields_property, fields);
+            rb_hash_aset(lookup_in_entry_res, deleted_property, lookup_in_entry.deleted ? Qtrue : Qfalse);
+            rb_hash_aset(lookup_in_entry_res, is_replica_property, lookup_in_entry.is_replica ? Qtrue : Qfalse);
+
+            for (std::size_t i = 0; i < entries_size; ++i) {
+                auto field_entry = lookup_in_entry.fields.at(i);
+                VALUE entry = rb_hash_new();
+                rb_hash_aset(entry, index_property, ULL2NUM(field_entry.original_index));
+                rb_hash_aset(entry, exists_property, field_entry.exists ? Qtrue : Qfalse);
+                rb_hash_aset(entry, path_property, cb_str_new(field_entry.path));
+                if (!field_entry.value.empty()) {
+                    rb_hash_aset(entry, value_property, cb_str_new(field_entry.value));
+                }
+                if (field_entry.ec && field_entry.ec != couchbase::errc::key_value::path_not_found) {
+                    rb_hash_aset(
+                      entry,
+                      error_property,
+                      cb_map_error_code(field_entry.ec,
+                                        fmt::format("error getting result for spec at index {}, path \"{}\"", i, field_entry.path)));
+                }
+                rb_ary_store(fields, static_cast<long>(i), entry);
+            }
+            rb_ary_store(res, static_cast<long>(j), lookup_in_entry_res);
+        }
+
         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));
@@ -3661,6 +3919,284 @@ cb_Backend_document_mutate_in(VALUE self, VALUE bucket, VALUE scope, VALUE colle
     return Qnil;
 }
 
+struct cb_core_scan_result_data {
+    std::unique_ptr<couchbase::core::scan_result> scan_result{};
+};
+
+static void
+cb_CoreScanResult_mark(void* ptr)
+{
+    /* No embedded Ruby objects */
+}
+
+static void
+cb_CoreScanResult_free(void* ptr)
+{
+    auto* data = static_cast<cb_core_scan_result_data*>(ptr);
+    if (data->scan_result != nullptr && !data->scan_result->is_cancelled()) {
+        data->scan_result->cancel();
+    }
+    data->scan_result.reset();
+    ruby_xfree(data);
+}
+
+static const rb_data_type_t cb_core_scan_result_type {
+    .wrap_struct_name = "Couchbase/Backend/CoreScanResult",
+    .function = {
+      .dmark = cb_CoreScanResult_mark,
+      .dfree = cb_CoreScanResult_free,
+    },
+    .data = nullptr,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+#endif
+};
+
+static VALUE
+cb_CoreScanResult_allocate(VALUE klass)
+{
+    cb_core_scan_result_data* data = nullptr;
+    VALUE obj = TypedData_Make_Struct(klass, cb_core_scan_result_data, &cb_core_scan_result_type, data);
+    return obj;
+}
+
+static VALUE
+cb_CoreScanResult_is_cancelled(VALUE self)
+{
+    cb_core_scan_result_data* data = nullptr;
+    TypedData_Get_Struct(self, cb_core_scan_result_data, &cb_core_scan_result_type, data);
+    auto resp = data->scan_result->is_cancelled();
+    if (resp) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+static VALUE
+cb_CoreScanResult_cancel(VALUE self)
+{
+    cb_core_scan_result_data* data = nullptr;
+    TypedData_Get_Struct(self, cb_core_scan_result_data, &cb_core_scan_result_type, data);
+    data->scan_result->cancel();
+    return Qnil;
+}
+
+static VALUE
+cb_CoreScanResult_next_item(VALUE self)
+{
+    try {
+        cb_core_scan_result_data* data = nullptr;
+        TypedData_Get_Struct(self, cb_core_scan_result_data, &cb_core_scan_result_type, data);
+        auto barrier = std::make_shared<std::promise<tl::expected<couchbase::core::range_scan_item, std::error_code>>>();
+        auto f = barrier->get_future();
+        data->scan_result->next([barrier](couchbase::core::range_scan_item item, std::error_code ec) {
+            if (ec) {
+                return barrier->set_value(tl::unexpected(ec));
+            } else {
+                return barrier->set_value(item);
+            }
+        });
+        auto resp = cb_wait_for_future(f);
+        if (!resp.has_value()) {
+            // If the error code is range_scan_completed return nil without raising an exception (nil signifies that there
+            // are no more items)
+            if (resp.error() != couchbase::errc::key_value::range_scan_completed) {
+                cb_throw_error_code(resp.error(), "unable to fetch next scan item");
+            }
+            // Release ownership of scan_result unique pointer
+            return Qnil;
+        }
+        auto item = resp.value();
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("id")), cb_str_new(item.key));
+        if (item.body.has_value()) {
+            auto body = item.body.value();
+            rb_hash_aset(res, rb_id2sym(rb_intern("id")), cb_str_new(item.key));
+            rb_hash_aset(res, rb_id2sym(rb_intern("encoded")), cb_str_new(body.value));
+            rb_hash_aset(res, rb_id2sym(rb_intern("cas")), cb_cas_to_num(body.cas));
+            rb_hash_aset(res, rb_id2sym(rb_intern("flags")), UINT2NUM(body.flags));
+            rb_hash_aset(res, rb_id2sym(rb_intern("expiry")), UINT2NUM(body.expiry));
+            rb_hash_aset(res, rb_id2sym(rb_intern("id_only")), Qfalse);
+        } else {
+            rb_hash_aset(res, rb_id2sym(rb_intern("id_only")), Qtrue);
+        }
+        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));
+    } catch (const ruby_exception& e) {
+        rb_exc_raise(e.exception_object());
+    }
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_document_scan_create(VALUE self, VALUE bucket, VALUE scope, VALUE collection, VALUE scan_type, VALUE options)
+{
+    const auto& cluster = cb_backend_to_cluster(self);
+
+    Check_Type(bucket, T_STRING);
+    Check_Type(scope, T_STRING);
+    Check_Type(collection, T_STRING);
+    Check_Type(scan_type, T_HASH);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
+
+    try {
+        couchbase::core::range_scan_orchestrator_options orchestrator_options{};
+        cb_extract_timeout(orchestrator_options, options);
+        cb_extract_option_bool(orchestrator_options.ids_only, options, "ids_only");
+        cb_extract_option_number(orchestrator_options.batch_item_limit, options, "batch_item_limit");
+        cb_extract_option_number(orchestrator_options.batch_byte_limit, options, "batch_byte_limit");
+        cb_extract_option_number(orchestrator_options.concurrency, options, "concurrency");
+
+        // Extracting the mutation state
+        if (VALUE mutation_state = rb_hash_aref(options, rb_id2sym(rb_intern("mutation_state"))); !NIL_P(mutation_state)) {
+            cb_check_type(mutation_state, T_ARRAY);
+            auto state_size = static_cast<std::size_t>(RARRAY_LEN(mutation_state));
+
+            if (state_size > 0) {
+                auto core_mut_state = couchbase::core::mutation_state{};
+                core_mut_state.tokens.reserve(state_size);
+                for (std::size_t i = 0; i < state_size; ++i) {
+                    VALUE token = rb_ary_entry(mutation_state, static_cast<long>(i));
+                    cb_check_type(token, T_HASH);
+                    VALUE bucket_name = rb_hash_aref(token, rb_id2sym(rb_intern("bucket_name")));
+                    cb_check_type(bucket_name, T_STRING);
+                    VALUE partition_id = rb_hash_aref(token, rb_id2sym(rb_intern("partition_id")));
+                    cb_check_type(partition_id, T_FIXNUM);
+                    VALUE partition_uuid = rb_hash_aref(token, rb_id2sym(rb_intern("partition_uuid")));
+                    switch (TYPE(partition_uuid)) {
+                        case T_FIXNUM:
+                        case T_BIGNUM:
+                            break;
+                        default:
+                            rb_raise(rb_eArgError, "partition_uuid must be an Integer");
+                    }
+                    VALUE sequence_number = rb_hash_aref(token, rb_id2sym(rb_intern("sequence_number")));
+                    switch (TYPE(sequence_number)) {
+                        case T_FIXNUM:
+                        case T_BIGNUM:
+                            break;
+                        default:
+                            rb_raise(rb_eArgError, "sequence_number must be an Integer");
+                    }
+                    core_mut_state.tokens.emplace_back(NUM2ULL(partition_uuid),
+                                                       NUM2ULL(sequence_number),
+                                                       gsl::narrow_cast<std::uint16_t>(NUM2UINT(partition_id)),
+                                                       cb_string_new(bucket_name));
+                }
+
+                orchestrator_options.consistent_with = core_mut_state;
+            }
+        }
+
+        auto bucket_name = cb_string_new(bucket);
+        auto scope_name = cb_string_new(scope);
+        auto collection_name = cb_string_new(collection);
+
+        // Getting the operation agent
+        auto agent_group = couchbase::core::agent_group(cluster->io_context(), couchbase::core::agent_group_config{ { cluster } });
+        agent_group.open_bucket(bucket_name);
+        auto agent = agent_group.get_agent(bucket_name);
+        if (!agent.has_value()) {
+            rb_raise(eCouchbaseError, "Cannot perform scan operation. Unable to get operation agent");
+            return Qnil;
+        }
+
+        // Getting the vbucket map
+        auto barrier = std::make_shared<std::promise<tl::expected<couchbase::core::topology::configuration, std::error_code>>>();
+        auto f = barrier->get_future();
+        cluster->with_bucket_configuration(bucket_name,
+                                           [barrier](std::error_code ec, const couchbase::core::topology::configuration& config) mutable {
+                                               if (ec) {
+                                                   return barrier->set_value(tl::unexpected(ec));
+                                               }
+                                               barrier->set_value(config);
+                                           });
+        auto config = cb_wait_for_future(f);
+        if (!config.has_value()) {
+            rb_raise(eCouchbaseError, "Cannot perform scan operation. Unable to get bucket configuration");
+            return Qnil;
+        }
+        if (!config->supports_range_scan()) {
+            rb_raise(eFeatureNotAvailable, "Server does not support key-value scan operations");
+            return Qnil;
+        }
+        auto vbucket_map = config->vbmap;
+        if (!vbucket_map || vbucket_map->empty()) {
+            rb_raise(eCouchbaseError, "Cannot perform scan operation. Unable to get vbucket map");
+            return Qnil;
+        }
+
+        // Constructing the scan type
+        std::variant<std::monostate, couchbase::core::range_scan, couchbase::core::prefix_scan, couchbase::core::sampling_scan>
+          core_scan_type{};
+        ID scan_type_id = rb_sym2id(rb_hash_aref(scan_type, rb_id2sym(rb_intern("scan_type"))));
+        if (scan_type_id == rb_intern("range")) {
+            auto range_scan = couchbase::core::range_scan{};
+
+            VALUE from_hash = rb_hash_aref(scan_type, rb_id2sym(rb_intern("from")));
+            VALUE to_hash = rb_hash_aref(scan_type, rb_id2sym(rb_intern("to")));
+
+            if (!NIL_P(from_hash)) {
+                Check_Type(from_hash, T_HASH);
+                range_scan.from = couchbase::core::scan_term{};
+                cb_extract_option_string(range_scan.from->term, from_hash, "term");
+                cb_extract_option_bool(range_scan.from->exclusive, from_hash, "exclusive");
+            }
+            if (!NIL_P(to_hash)) {
+                Check_Type(to_hash, T_HASH);
+                range_scan.to = couchbase::core::scan_term{};
+                cb_extract_option_string(range_scan.to->term, to_hash, "term");
+                cb_extract_option_bool(range_scan.to->exclusive, to_hash, "exclusive");
+            }
+            core_scan_type = range_scan;
+        } else if (scan_type_id == rb_intern("prefix")) {
+            auto prefix_scan = couchbase::core::prefix_scan{};
+            cb_extract_option_string(prefix_scan.prefix, scan_type, "prefix");
+            core_scan_type = prefix_scan;
+        } else if (scan_type_id == rb_intern("sampling")) {
+            auto sampling_scan = couchbase::core::sampling_scan{};
+            cb_extract_option_number(sampling_scan.limit, scan_type, "limit");
+            cb_extract_option_number(sampling_scan.seed, scan_type, "seed");
+            core_scan_type = sampling_scan;
+        } else {
+            rb_raise(eInvalidArgument, "Invalid scan operation type");
+        }
+
+        auto orchestrator = couchbase::core::range_scan_orchestrator(
+          cluster->io_context(), agent.value(), vbucket_map.value(), scope_name, collection_name, core_scan_type, orchestrator_options);
+
+        // Start the scan
+        auto resp = orchestrator.scan();
+        if (!resp.has_value()) {
+            cb_throw_error_code(resp.error(), "unable to start scan");
+        }
+
+        // Wrap core scan_result inside Ruby ScanResult
+        // Creating a Ruby CoreScanResult object *after* checking that no error occurred during orchestrator.scan()
+        VALUE cCoreScanResult = rb_define_class_under(rb_define_module("Couchbase"), "CoreScanResult", rb_cObject);
+        rb_define_alloc_func(cCoreScanResult, cb_CoreScanResult_allocate);
+        rb_define_method(cCoreScanResult, "next_item", VALUE_FUNC(cb_CoreScanResult_next_item), 0);
+        rb_define_method(cCoreScanResult, "cancelled?", VALUE_FUNC(cb_CoreScanResult_is_cancelled), 0);
+        rb_define_method(cCoreScanResult, "cancel", VALUE_FUNC(cb_CoreScanResult_cancel), 0);
+        VALUE core_scan_result_obj = rb_class_new_instance(0, NULL, cCoreScanResult);
+        rb_ivar_set(core_scan_result_obj, rb_intern("@backend"), self);
+        cb_core_scan_result_data* data = nullptr;
+        TypedData_Get_Struct(core_scan_result_obj, cb_core_scan_result_data, &cb_core_scan_result_type, data);
+        data->scan_result = std::make_unique<couchbase::core::scan_result>(resp.value());
+        return core_scan_result_obj;
+
+    } catch (const std::system_error& se) {
+        rb_exc_raise(cb_map_error_code(se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
+    } catch (const ruby_exception& e) {
+        rb_exc_raise(e.exception_object());
+    }
+    return Qnil;
+}
+
 static int
 cb_for_each_named_param(VALUE key, VALUE value, VALUE arg)
 {
@@ -3696,6 +4232,7 @@ cb_Backend_document_query(VALUE self, VALUE statement, VALUE options)
         cb_extract_option_bool(req.readonly, options, "readonly");
         cb_extract_option_bool(req.flex_index, options, "flex_index");
         cb_extract_option_bool(req.preserve_expiry, options, "preserve_expiry");
+        cb_extract_option_bool(req.use_replica, options, "use_replica");
         cb_extract_option_uint64(req.scan_cap, options, "scan_cap");
         cb_extract_duration(req.scan_wait, options, "scan_wait");
         cb_extract_option_uint64(req.max_parallelism, options, "max_parallelism");
@@ -8577,10 +9114,20 @@ cb_Backend_form_encode(VALUE self, VALUE data)
     return cb_str_new(encoded);
 }
 
+static VALUE
+cb_Backend_enable_protocol_logger_to_save_network_traffic_to_file(VALUE /* self */, VALUE path)
+{
+    Check_Type(path, T_STRING);
+    couchbase::core::logger::configuration configuration{};
+    configuration.filename = cb_string_new(path);
+    couchbase::core::logger::create_protocol_logger(configuration);
+    return Qnil;
+}
+
 static void
 init_backend(VALUE mCouchbase)
 {
-    VALUE cBackend = rb_define_class_under(mCouchbase, "Backend", rb_cBasicObject);
+    VALUE cBackend = rb_define_class_under(mCouchbase, "Backend", rb_cObject);
     rb_define_alloc_func(cBackend, cb_Backend_allocate);
     rb_define_method(cBackend, "open", VALUE_FUNC(cb_Backend_open), 3);
     rb_define_method(cBackend, "close", VALUE_FUNC(cb_Backend_close), 0);
@@ -8604,7 +9151,10 @@ init_backend(VALUE mCouchbase)
     rb_define_method(cBackend, "document_remove", VALUE_FUNC(cb_Backend_document_remove), 5);
     rb_define_method(cBackend, "document_remove_multi", VALUE_FUNC(cb_Backend_document_remove_multi), 5);
     rb_define_method(cBackend, "document_lookup_in", VALUE_FUNC(cb_Backend_document_lookup_in), 6);
+    rb_define_method(cBackend, "document_lookup_in_any_replica", VALUE_FUNC(cb_Backend_document_lookup_in_any_replica), 6);
+    rb_define_method(cBackend, "document_lookup_in_all_replicas", VALUE_FUNC(cb_Backend_document_lookup_in_all_replicas), 6);
     rb_define_method(cBackend, "document_mutate_in", VALUE_FUNC(cb_Backend_document_mutate_in), 6);
+    rb_define_method(cBackend, "document_scan_create", VALUE_FUNC(cb_Backend_document_scan_create), 5);
     rb_define_method(cBackend, "document_query", VALUE_FUNC(cb_Backend_document_query), 2);
     rb_define_method(cBackend, "document_touch", VALUE_FUNC(cb_Backend_document_touch), 6);
     rb_define_method(cBackend, "document_exists", VALUE_FUNC(cb_Backend_document_exists), 5);
@@ -8706,6 +9256,10 @@ init_backend(VALUE mCouchbase)
     rb_define_singleton_method(cBackend, "query_escape", VALUE_FUNC(cb_Backend_query_escape), 1);
     rb_define_singleton_method(cBackend, "path_escape", VALUE_FUNC(cb_Backend_path_escape), 1);
     rb_define_singleton_method(cBackend, "form_encode", VALUE_FUNC(cb_Backend_form_encode), 1);
+    rb_define_singleton_method(cBackend,
+                               "enable_protocol_logger_to_save_network_traffic_to_file",
+                               VALUE_FUNC(cb_Backend_enable_protocol_logger_to_save_network_traffic_to_file),
+                               1);
 }
 
 void