couchbase 3.0.0 → 3.0.1

data/ext/couchbase/couchbase.cxx

@@ -16,6 +16,7 @@
  */
 
 #include <build_config.hxx>
+#include <build_info.hxx>
 
 #include <openssl/crypto.h>
 #include <asio/version.hpp>
@@ -94,6 +95,32 @@ init_versions(VALUE mCouchbase)
     VALUE version_info = rb_inspect(cb_Version);
     spdlog::info("couchbase backend has been initialized: {}",
                  std::string_view(RSTRING_PTR(version_info), static_cast<std::size_t>(RSTRING_LEN(version_info))));
+
+    VALUE cb_BuildInfo = rb_hash_new();
+    rb_const_set(mCouchbase, rb_intern("BUILD_INFO"), cb_BuildInfo);
+    rb_hash_aset(cb_BuildInfo, rb_id2sym(rb_intern("cmake_build_type")), rb_str_freeze(rb_str_new_cstr(CMAKE_BUILD_TYPE)));
+    rb_hash_aset(cb_BuildInfo, rb_id2sym(rb_intern("compile_definitions")), rb_str_freeze(rb_str_new_cstr(BACKEND_COMPILE_DEFINITIONS)));
+    rb_hash_aset(cb_BuildInfo, rb_id2sym(rb_intern("compile_features")), rb_str_freeze(rb_str_new_cstr(BACKEND_COMPILE_FEATURES)));
+    rb_hash_aset(cb_BuildInfo, rb_id2sym(rb_intern("compile_flags")), rb_str_freeze(rb_str_new_cstr(BACKEND_COMPILE_FLAGS)));
+    rb_hash_aset(cb_BuildInfo, rb_id2sym(rb_intern("compile_options")), rb_str_freeze(rb_str_new_cstr(BACKEND_COMPILE_OPTIONS)));
+    rb_hash_aset(cb_BuildInfo, rb_id2sym(rb_intern("link_depends")), rb_str_freeze(rb_str_new_cstr(BACKEND_LINK_DEPENDS)));
+    rb_hash_aset(cb_BuildInfo, rb_id2sym(rb_intern("link_flags")), rb_str_freeze(rb_str_new_cstr(BACKEND_LINK_FLAGS)));
+    rb_hash_aset(cb_BuildInfo, rb_id2sym(rb_intern("link_libraries")), rb_str_freeze(rb_str_new_cstr(BACKEND_LINK_LIBRARIES)));
+    rb_hash_aset(cb_BuildInfo, rb_id2sym(rb_intern("link_options")), rb_str_freeze(rb_str_new_cstr(BACKEND_LINK_OPTIONS)));
+#if defined(STATIC_STDLIB)
+    rb_hash_aset(cb_BuildInfo, rb_id2sym(rb_intern("static_stdlib")), Qtrue);
+#endif
+    rb_hash_aset(cb_BuildInfo, rb_id2sym(rb_intern("openssl_crypto_libraries")), rb_str_freeze(rb_str_new_cstr(OPENSSL_CRYPTO_LIBRARIES)));
+    rb_hash_aset(cb_BuildInfo, rb_id2sym(rb_intern("openssl_ssl_libraries")), rb_str_freeze(rb_str_new_cstr(OPENSSL_SSL_LIBRARIES)));
+    rb_hash_aset(cb_BuildInfo, rb_id2sym(rb_intern("openssl_include_dir")), rb_str_freeze(rb_str_new_cstr(OPENSSL_INCLUDE_DIR)));
+#if defined(STATIC_OPENSSL)
+    rb_hash_aset(cb_BuildInfo, rb_id2sym(rb_intern("static_openssl")), Qtrue);
+#endif
+    rb_hash_aset(cb_BuildInfo, rb_id2sym(rb_intern("ruby_library")), rb_str_freeze(rb_str_new_cstr(RUBY_LIBRARY)));
+    rb_hash_aset(cb_BuildInfo, rb_id2sym(rb_intern("ruby_include_dir")), rb_str_freeze(rb_str_new_cstr(RUBY_INCLUDE_DIR)));
+    VALUE build_info = rb_inspect(cb_BuildInfo);
+    spdlog::debug("couchbase backend build info: {}",
+                  std::string_view(RSTRING_PTR(build_info), static_cast<std::size_t>(RSTRING_LEN(build_info))));
 }
 
 struct cb_backend_data {
@@ -177,6 +204,7 @@ static VALUE eCasMismatch;
 static VALUE eCollectionExists;
 static VALUE eCollectionNotFound;
 static VALUE eCompilationFailure;
+static VALUE eConsistencyMismatch;
 static VALUE eDatasetExists;
 static VALUE eDatasetNotFound;
 static VALUE eDataverseExists;
@@ -233,6 +261,14 @@ static VALUE eXattrInvalidKeyCombo;
 static VALUE eXattrUnknownMacro;
 static VALUE eXattrUnknownVirtualAttribute;
 
+static VALUE eBackendError;
+static VALUE eNetworkError;
+static VALUE eResolveFailure;
+static VALUE eNoEndpointsLeft;
+static VALUE eHandshakeFailure;
+static VALUE eProtocolError;
+static VALUE eConfigurationNotAvailable;
+
 static void
 init_exceptions(VALUE mCouchbase)
 {
@@ -250,6 +286,7 @@ init_exceptions(VALUE mCouchbase)
     eCollectionExists = rb_define_class_under(mError, "CollectionExists", eCouchbaseError);
     eCollectionNotFound = rb_define_class_under(mError, "CollectionNotFound", eCouchbaseError);
     eCompilationFailure = rb_define_class_under(mError, "CompilationFailure", eCouchbaseError);
+    eConsistencyMismatch = rb_define_class_under(mError, "ConsistencyMismatch", eCouchbaseError);
     eDatasetExists = rb_define_class_under(mError, "DatasetExists", eCouchbaseError);
     eDatasetNotFound = rb_define_class_under(mError, "DatasetNotFound", eCouchbaseError);
     eDataverseExists = rb_define_class_under(mError, "DataverseExists", eCouchbaseError);
@@ -305,6 +342,14 @@ init_exceptions(VALUE mCouchbase)
     eXattrInvalidKeyCombo = rb_define_class_under(mError, "XattrInvalidKeyCombo", eCouchbaseError);
     eXattrUnknownMacro = rb_define_class_under(mError, "XattrUnknownMacro", eCouchbaseError);
     eXattrUnknownVirtualAttribute = rb_define_class_under(mError, "XattrUnknownVirtualAttribute", eCouchbaseError);
+
+    eBackendError = rb_define_class_under(mError, "BackendError", eCouchbaseError);
+    eNetworkError = rb_define_class_under(mError, "NetworkError", eBackendError);
+    eResolveFailure = rb_define_class_under(mError, "ResolveFailure", eNetworkError);
+    eNoEndpointsLeft = rb_define_class_under(mError, "NoEndpointsLeft", eNetworkError);
+    eHandshakeFailure = rb_define_class_under(mError, "HandshakeFailure", eNetworkError);
+    eProtocolError = rb_define_class_under(mError, "ProtocolError", eNetworkError);
+    eConfigurationNotAvailable = rb_define_class_under(mError, "ConfigurationNotAvailable", eNetworkError);
 }
 
 static VALUE
@@ -461,6 +506,8 @@ cb__map_error_code(std::error_code ec, const std::string& message)
         switch (static_cast<couchbase::error::search_errc>(ec.value())) {
             case couchbase::error::search_errc::index_not_ready:
                 return rb_exc_new_cstr(eIndexNotReady, fmt::format("{}: {}", message, ec.message()).c_str());
+            case couchbase::error::search_errc::consistency_mismatch:
+                return rb_exc_new_cstr(eConsistencyMismatch, fmt::format("{}: {}", message, ec.message()).c_str());
         }
     } else if (ec.category() == couchbase::error::detail::get_view_category()) {
         switch (static_cast<couchbase::error::view_errc>(ec.value())) {
@@ -516,9 +563,26 @@ cb__map_error_code(std::error_code ec, const std::string& message)
             case couchbase::error::management_errc::bucket_not_flushable:
                 return rb_exc_new_cstr(eBucketNotFlushable, fmt::format("{}: {}", message, ec.message()).c_str());
         }
+    } else if (ec.category() == couchbase::error::detail::network_error_category()) {
+        switch (static_cast<couchbase::error::network_errc>(ec.value())) {
+            case couchbase::error::network_errc::resolve_failure:
+                return rb_exc_new_cstr(eResolveFailure, fmt::format("{}: {}", message, ec.message()).c_str());
+
+            case couchbase::error::network_errc::no_endpoints_left:
+                return rb_exc_new_cstr(eNoEndpointsLeft, fmt::format("{}: {}", message, ec.message()).c_str());
+
+            case couchbase::error::network_errc::handshake_failure:
+                return rb_exc_new_cstr(eHandshakeFailure, fmt::format("{}: {}", message, ec.message()).c_str());
+
+            case couchbase::error::network_errc::protocol_error:
+                return rb_exc_new_cstr(eProtocolError, fmt::format("{}: {}", message, ec.message()).c_str());
+
+            case couchbase::error::network_errc::configuration_not_available:
+                return rb_exc_new_cstr(eConfigurationNotAvailable, fmt::format("{}: {}", message, ec.message()).c_str());
+        }
     }
 
-    return rb_exc_new_cstr(eCouchbaseError, fmt::format("{}: {}", message, ec.message()).c_str());
+    return rb_exc_new_cstr(eBackendError, fmt::format("{}: {}", message, ec.message()).c_str());
 }
 
 static VALUE
@@ -593,6 +657,93 @@ cb_Backend_close(VALUE self)
     return Qnil;
 }
 
+static VALUE
+cb_Backend_diagnostics(VALUE self, VALUE report_id)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    if (!NIL_P(report_id)) {
+        Check_Type(report_id, T_STRING);
+    }
+
+    VALUE exc = Qnil;
+    do {
+        std::optional<std::string> id;
+        if (!NIL_P(report_id)) {
+            id.emplace(std::string(RSTRING_PTR(report_id), static_cast<size_t>(RSTRING_LEN(report_id))));
+        }
+        auto barrier = std::make_shared<std::promise<couchbase::diag::diagnostics_result>>();
+        auto f = barrier->get_future();
+        backend->cluster->diagnostics(id, [barrier](couchbase::diag::diagnostics_result resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("id")), rb_str_new(resp.id.data(), static_cast<long>(resp.id.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("sdk")), rb_str_new(resp.sdk.data(), static_cast<long>(resp.sdk.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("version")), INT2FIX(resp.version));
+        VALUE services = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("services")), services);
+        for (const auto& svcs : resp.services) {
+            VALUE type = Qnil;
+            switch (svcs.first) {
+                case couchbase::service_type::kv:
+                    type = rb_id2sym(rb_intern("kv"));
+                    break;
+                case couchbase::service_type::query:
+                    type = rb_id2sym(rb_intern("query"));
+                    break;
+                case couchbase::service_type::analytics:
+                    type = rb_id2sym(rb_intern("analytics"));
+                    break;
+                case couchbase::service_type::search:
+                    type = rb_id2sym(rb_intern("search"));
+                    break;
+                case couchbase::service_type::views:
+                    type = rb_id2sym(rb_intern("views"));
+                    break;
+                case couchbase::service_type::management:
+                    type = rb_id2sym(rb_intern("mgmt"));
+                    break;
+            }
+            VALUE endpoints = rb_ary_new();
+            rb_hash_aset(services, type, endpoints);
+            for (const auto& svc : svcs.second) {
+                VALUE service = rb_hash_new();
+                if (svc.last_activity) {
+                    rb_hash_aset(service, rb_id2sym(rb_intern("last_activity_us")), LL2NUM(svc.last_activity->count()));
+                }
+                rb_hash_aset(service, rb_id2sym(rb_intern("id")), rb_str_new(svc.id.data(), static_cast<long>(svc.id.size())));
+                rb_hash_aset(service, rb_id2sym(rb_intern("remote")), rb_str_new(svc.remote.data(), static_cast<long>(svc.remote.size())));
+                rb_hash_aset(service, rb_id2sym(rb_intern("local")), rb_str_new(svc.local.data(), static_cast<long>(svc.local.size())));
+                VALUE state = Qnil;
+                switch (svc.state) {
+                    case couchbase::diag::endpoint_state::disconnected:
+                        state = rb_id2sym(rb_intern("disconnected"));
+                        break;
+                    case couchbase::diag::endpoint_state::connecting:
+                        state = rb_id2sym(rb_intern("connecting"));
+                        break;
+                    case couchbase::diag::endpoint_state::connected:
+                        state = rb_id2sym(rb_intern("connected"));
+                        break;
+                    case couchbase::diag::endpoint_state::disconnecting:
+                        state = rb_id2sym(rb_intern("disconnecting"));
+                        break;
+                }
+                rb_hash_aset(service, rb_id2sym(rb_intern("state")), state);
+                rb_ary_push(endpoints, service);
+            }
+        }
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
 static VALUE
 cb_Backend_open_bucket(VALUE self, VALUE bucket, VALUE wait_until_ready)
 {
@@ -1976,6 +2127,10 @@ cb_Backend_document_query(VALUE self, VALUE statement, VALUE options)
         if (!NIL_P(readonly)) {
             req.readonly = RTEST(readonly);
         }
+        VALUE flex_index = rb_hash_aref(options, rb_id2sym(rb_intern("flex_index")));
+        if (!NIL_P(flex_index)) {
+            req.flex_index = RTEST(flex_index);
+        }
         VALUE scan_cap = rb_hash_aref(options, rb_id2sym(rb_intern("scan_cap")));
         if (!NIL_P(scan_cap)) {
             req.scan_cap = NUM2ULONG(scan_cap);
@@ -2101,14 +2256,18 @@ cb_Backend_document_query(VALUE self, VALUE statement, VALUE options)
             if (resp.payload.meta_data.errors && !resp.payload.meta_data.errors->empty()) {
                 const auto& first_error = resp.payload.meta_data.errors->front();
                 exc = cb__map_error_code(resp.ec,
-                                         fmt::format("unable to query: \"{}{}\" ({}: {})",
-                                                     req.statement.substr(0, 50),
-                                                     req.statement.size() > 50 ? "..." : "",
+                                         fmt::format(R"(unable to query (client_context_id="{}"): "{}{}" ({}: {}))",
+                                                     req.client_context_id,
+                                                     req.statement.substr(0, 100),
+                                                     req.statement.size() > 100 ? "..." : "",
                                                      first_error.code,
                                                      first_error.message));
             } else {
-                exc = cb__map_error_code(
-                  resp.ec, fmt::format("unable to query: \"{}{}\"", req.statement.substr(0, 50), req.statement.size() > 50 ? "..." : ""));
+                exc = cb__map_error_code(resp.ec,
+                                         fmt::format(R"(unable to query (client_context_id="{}"): "{}{}")",
+                                                     req.client_context_id,
+                                                     req.statement.substr(0, 100),
+                                                     req.statement.size() > 100 ? "..." : ""));
             }
             break;
         }
@@ -2142,16 +2301,20 @@ cb_Backend_document_query(VALUE self, VALUE statement, VALUE options)
         }
         metrics = rb_hash_new();
         rb_hash_aset(meta, rb_id2sym(rb_intern("metrics")), metrics);
-        rb_hash_aset(metrics,
-                     rb_id2sym(rb_intern("elapsed_time")),
-                     rb_str_new(resp.payload.meta_data.metrics.elapsed_time.data(),
-                                static_cast<long>(resp.payload.meta_data.metrics.elapsed_time.size())));
-        rb_hash_aset(metrics,
-                     rb_id2sym(rb_intern("execution_time")),
-                     rb_str_new(resp.payload.meta_data.metrics.execution_time.data(),
-                                static_cast<long>(resp.payload.meta_data.metrics.execution_time.size())));
+        if (!resp.payload.meta_data.metrics.elapsed_time.empty()) {
+            rb_hash_aset(metrics,
+                         rb_id2sym(rb_intern("elapsed_time")),
+                         rb_str_new(resp.payload.meta_data.metrics.elapsed_time.data(),
+                                    static_cast<long>(resp.payload.meta_data.metrics.elapsed_time.size())));
+        }
+        if (!resp.payload.meta_data.metrics.execution_time.empty()) {
+            rb_hash_aset(metrics,
+                         rb_id2sym(rb_intern("execution_time")),
+                         rb_str_new(resp.payload.meta_data.metrics.execution_time.data(),
+                                    static_cast<long>(resp.payload.meta_data.metrics.execution_time.size())));
+        }
         rb_hash_aset(metrics, rb_id2sym(rb_intern("result_count")), ULL2NUM(resp.payload.meta_data.metrics.result_count));
-        rb_hash_aset(metrics, rb_id2sym(rb_intern("result_size")), ULL2NUM(resp.payload.meta_data.metrics.result_count));
+        rb_hash_aset(metrics, rb_id2sym(rb_intern("result_size")), ULL2NUM(resp.payload.meta_data.metrics.result_size));
         if (resp.payload.meta_data.metrics.sort_count) {
             rb_hash_aset(metrics, rb_id2sym(rb_intern("sort_count")), ULL2NUM(*resp.payload.meta_data.metrics.sort_count));
         }
@@ -2239,15 +2402,19 @@ cb__generate_bucket_settings(VALUE bucket, couchbase::operations::bucket_setting
         }
     }
     {
-        VALUE ejection_policy = rb_hash_aref(bucket, rb_id2sym(rb_intern("ejection_policy")));
-        if (!NIL_P(ejection_policy)) {
-            Check_Type(ejection_policy, T_SYMBOL);
-            if (ejection_policy == rb_id2sym(rb_intern("full"))) {
-                entry.ejection_policy = couchbase::operations::bucket_settings::ejection_policy::full;
-            } else if (ejection_policy == rb_id2sym(rb_intern("value_only"))) {
-                entry.ejection_policy = couchbase::operations::bucket_settings::ejection_policy::value_only;
+        VALUE eviction_policy = rb_hash_aref(bucket, rb_id2sym(rb_intern("eviction_policy")));
+        if (!NIL_P(eviction_policy)) {
+            Check_Type(eviction_policy, T_SYMBOL);
+            if (eviction_policy == rb_id2sym(rb_intern("full"))) {
+                entry.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::full;
+            } else if (eviction_policy == rb_id2sym(rb_intern("value_only"))) {
+                entry.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::value_only;
+            } else if (eviction_policy == rb_id2sym(rb_intern("no_eviction"))) {
+                entry.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::no_eviction;
+            } else if (eviction_policy == rb_id2sym(rb_intern("not_recently_used"))) {
+                entry.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::not_recently_used;
             } else {
-                rb_raise(rb_eArgError, "unknown ejection policy");
+                rb_raise(rb_eArgError, "unknown eviction policy");
             }
         }
     }
@@ -2435,15 +2602,21 @@ cb__extract_bucket_settings(const couchbase::operations::bucket_settings& entry,
     rb_hash_aset(bucket, rb_id2sym(rb_intern("num_replicas")), ULONG2NUM(entry.num_replicas));
     rb_hash_aset(bucket, rb_id2sym(rb_intern("replica_indexes")), entry.replica_indexes ? Qtrue : Qfalse);
     rb_hash_aset(bucket, rb_id2sym(rb_intern("flush_enabled")), entry.flush_enabled ? Qtrue : Qfalse);
-    switch (entry.ejection_policy) {
-        case couchbase::operations::bucket_settings::ejection_policy::full:
-            rb_hash_aset(bucket, rb_id2sym(rb_intern("ejection_policy")), rb_id2sym(rb_intern("full")));
+    switch (entry.eviction_policy) {
+        case couchbase::operations::bucket_settings::eviction_policy::full:
+            rb_hash_aset(bucket, rb_id2sym(rb_intern("eviction_policy")), rb_id2sym(rb_intern("full")));
+            break;
+        case couchbase::operations::bucket_settings::eviction_policy::value_only:
+            rb_hash_aset(bucket, rb_id2sym(rb_intern("eviction_policy")), rb_id2sym(rb_intern("value_only")));
             break;
-        case couchbase::operations::bucket_settings::ejection_policy::value_only:
-            rb_hash_aset(bucket, rb_id2sym(rb_intern("ejection_policy")), rb_id2sym(rb_intern("value_only")));
+        case couchbase::operations::bucket_settings::eviction_policy::no_eviction:
+            rb_hash_aset(bucket, rb_id2sym(rb_intern("eviction_policy")), rb_id2sym(rb_intern("no_eviction")));
             break;
-        case couchbase::operations::bucket_settings::ejection_policy::unknown:
-            rb_hash_aset(bucket, rb_id2sym(rb_intern("ejection_policy")), Qnil);
+        case couchbase::operations::bucket_settings::eviction_policy::not_recently_used:
+            rb_hash_aset(bucket, rb_id2sym(rb_intern("eviction_policy")), rb_id2sym(rb_intern("not_recently_used")));
+            break;
+        case couchbase::operations::bucket_settings::eviction_policy::unknown:
+            rb_hash_aset(bucket, rb_id2sym(rb_intern("eviction_policy")), Qnil);
             break;
     }
     switch (entry.conflict_resolution_type) {
@@ -2546,6 +2719,574 @@ cb_Backend_bucket_get(VALUE self, VALUE bucket_name, VALUE timeout)
     return Qnil;
 }
 
+static void
+cb__extract_role(const couchbase::operations::rbac::role_and_description& entry, VALUE role)
+{
+    rb_hash_aset(role, rb_id2sym(rb_intern("name")), rb_str_new(entry.name.data(), static_cast<long>(entry.name.size())));
+    rb_hash_aset(
+      role, rb_id2sym(rb_intern("display_name")), rb_str_new(entry.display_name.data(), static_cast<long>(entry.display_name.size())));
+    rb_hash_aset(
+      role, rb_id2sym(rb_intern("description")), rb_str_new(entry.description.data(), static_cast<long>(entry.description.size())));
+    if (entry.bucket) {
+        rb_hash_aset(role, rb_id2sym(rb_intern("bucket")), rb_str_new(entry.bucket->data(), static_cast<long>(entry.bucket->size())));
+    }
+    if (entry.scope) {
+        rb_hash_aset(role, rb_id2sym(rb_intern("scope")), rb_str_new(entry.scope->data(), static_cast<long>(entry.scope->size())));
+    }
+    if (entry.collection) {
+        rb_hash_aset(
+          role, rb_id2sym(rb_intern("collection")), rb_str_new(entry.collection->data(), static_cast<long>(entry.collection->size())));
+    }
+}
+
+static VALUE
+cb_Backend_role_get_all(VALUE self, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::role_get_all_request req{};
+        cb__extract_timeout(req, timeout);
+        auto barrier = std::make_shared<std::promise<couchbase::operations::role_get_all_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req,
+                                       [barrier](couchbase::operations::role_get_all_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, "unable to fetch users");
+            break;
+        }
+
+        VALUE res = rb_ary_new_capa(static_cast<long>(resp.roles.size()));
+        for (const auto& entry : resp.roles) {
+            VALUE role = rb_hash_new();
+            cb__extract_role(entry, role);
+            rb_ary_push(res, role);
+        }
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static void
+cb__extract_user(const couchbase::operations::rbac::user_and_metadata& entry, VALUE user)
+{
+    rb_hash_aset(user, rb_id2sym(rb_intern("username")), rb_str_new(entry.username.data(), static_cast<long>(entry.username.size())));
+    switch (entry.domain) {
+        case couchbase::operations::rbac::auth_domain::local:
+            rb_hash_aset(user, rb_id2sym(rb_intern("domain")), rb_id2sym(rb_intern("local")));
+            break;
+        case couchbase::operations::rbac::auth_domain::external:
+            rb_hash_aset(user, rb_id2sym(rb_intern("domain")), rb_id2sym(rb_intern("external")));
+            break;
+        case couchbase::operations::rbac::auth_domain::unknown:
+            break;
+    }
+    VALUE external_groups = rb_ary_new_capa(static_cast<long>(entry.external_groups.size()));
+    for (const auto& group : entry.external_groups) {
+        rb_ary_push(external_groups, rb_str_new(group.data(), static_cast<long>(group.size())));
+    }
+    rb_hash_aset(user, rb_id2sym(rb_intern("external_groups")), external_groups);
+    VALUE groups = rb_ary_new_capa(static_cast<long>(entry.groups.size()));
+    for (const auto& group : entry.groups) {
+        rb_ary_push(groups, rb_str_new(group.data(), static_cast<long>(group.size())));
+    }
+    rb_hash_aset(user, rb_id2sym(rb_intern("groups")), groups);
+    if (entry.display_name) {
+        rb_hash_aset(user,
+                     rb_id2sym(rb_intern("display_name")),
+                     rb_str_new(entry.display_name->data(), static_cast<long>(entry.display_name->size())));
+    }
+    if (entry.password_changed) {
+        rb_hash_aset(user,
+                     rb_id2sym(rb_intern("password_changed")),
+                     rb_str_new(entry.password_changed->data(), static_cast<long>(entry.password_changed->size())));
+    }
+    VALUE effective_roles = rb_ary_new_capa(static_cast<long>(entry.effective_roles.size()));
+    for (const auto& er : entry.effective_roles) {
+        VALUE role = rb_hash_new();
+        rb_hash_aset(role, rb_id2sym(rb_intern("name")), rb_str_new(er.name.data(), static_cast<long>(er.name.size())));
+        if (er.bucket) {
+            rb_hash_aset(role, rb_id2sym(rb_intern("bucket")), rb_str_new(er.bucket->data(), static_cast<long>(er.bucket->size())));
+        }
+        if (er.scope) {
+            rb_hash_aset(role, rb_id2sym(rb_intern("scope")), rb_str_new(er.scope->data(), static_cast<long>(er.scope->size())));
+        }
+        if (er.collection) {
+            rb_hash_aset(
+              role, rb_id2sym(rb_intern("collection")), rb_str_new(er.collection->data(), static_cast<long>(er.collection->size())));
+        }
+        VALUE origins = rb_ary_new_capa(static_cast<long>(er.origins.size()));
+        for (const auto& orig : er.origins) {
+            VALUE origin = rb_hash_new();
+            rb_hash_aset(origin, rb_id2sym(rb_intern("type")), rb_str_new(orig.type.data(), static_cast<long>(orig.type.size())));
+            if (orig.name) {
+                rb_hash_aset(origin, rb_id2sym(rb_intern("name")), rb_str_new(orig.name->data(), static_cast<long>(orig.name->size())));
+            }
+            rb_ary_push(origins, origin);
+        }
+        rb_hash_aset(role, rb_id2sym(rb_intern("origins")), origins);
+        rb_ary_push(effective_roles, role);
+    }
+    rb_hash_aset(user, rb_id2sym(rb_intern("effective_roles")), effective_roles);
+
+    VALUE roles = rb_ary_new_capa(static_cast<long>(entry.roles.size()));
+    for (const auto& er : entry.roles) {
+        VALUE role = rb_hash_new();
+        rb_hash_aset(role, rb_id2sym(rb_intern("name")), rb_str_new(er.name.data(), static_cast<long>(er.name.size())));
+        if (er.bucket) {
+            rb_hash_aset(role, rb_id2sym(rb_intern("bucket")), rb_str_new(er.bucket->data(), static_cast<long>(er.bucket->size())));
+        }
+        if (er.scope) {
+            rb_hash_aset(role, rb_id2sym(rb_intern("scope")), rb_str_new(er.scope->data(), static_cast<long>(er.scope->size())));
+        }
+        if (er.collection) {
+            rb_hash_aset(
+              role, rb_id2sym(rb_intern("collection")), rb_str_new(er.collection->data(), static_cast<long>(er.collection->size())));
+        }
+        rb_ary_push(roles, role);
+    }
+    rb_hash_aset(user, rb_id2sym(rb_intern("roles")), roles);
+}
+
+static VALUE
+cb_Backend_user_get_all(VALUE self, VALUE domain, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(domain, T_SYMBOL);
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::user_get_all_request req{};
+        cb__extract_timeout(req, timeout);
+        if (domain == rb_id2sym(rb_intern("local"))) {
+            req.domain = couchbase::operations::rbac::auth_domain::local;
+        } else if (domain == rb_id2sym(rb_intern("external"))) {
+            req.domain = couchbase::operations::rbac::auth_domain::external;
+        } else {
+            exc = rb_exc_new_str(eInvalidArgument, rb_sprintf("unsupported authentication domain: %+" PRIsVALUE, domain));
+            break;
+        }
+        auto barrier = std::make_shared<std::promise<couchbase::operations::user_get_all_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req,
+                                       [barrier](couchbase::operations::user_get_all_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, "unable to fetch users");
+            break;
+        }
+
+        VALUE res = rb_ary_new_capa(static_cast<long>(resp.users.size()));
+        for (const auto& entry : resp.users) {
+            VALUE user = rb_hash_new();
+            cb__extract_user(entry, user);
+            rb_ary_push(res, user);
+        }
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_user_get(VALUE self, VALUE domain, VALUE username, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(domain, T_SYMBOL);
+    Check_Type(username, T_STRING);
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::user_get_request req{};
+        cb__extract_timeout(req, timeout);
+        if (domain == rb_id2sym(rb_intern("local"))) {
+            req.domain = couchbase::operations::rbac::auth_domain::local;
+        } else if (domain == rb_id2sym(rb_intern("external"))) {
+            req.domain = couchbase::operations::rbac::auth_domain::external;
+        } else {
+            exc = rb_exc_new_str(eInvalidArgument, rb_sprintf("unsupported authentication domain: %+" PRIsVALUE, domain));
+            break;
+        }
+        req.username.assign(RSTRING_PTR(username), static_cast<size_t>(RSTRING_LEN(username)));
+        auto barrier = std::make_shared<std::promise<couchbase::operations::user_get_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req, [barrier](couchbase::operations::user_get_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to fetch user "{}")", req.username).c_str());
+            break;
+        }
+
+        VALUE res = rb_hash_new();
+        cb__extract_user(resp.user, res);
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_user_drop(VALUE self, VALUE domain, VALUE username, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(domain, T_SYMBOL);
+    Check_Type(username, T_STRING);
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::user_drop_request req{};
+        cb__extract_timeout(req, timeout);
+        if (domain == rb_id2sym(rb_intern("local"))) {
+            req.domain = couchbase::operations::rbac::auth_domain::local;
+        } else if (domain == rb_id2sym(rb_intern("external"))) {
+            req.domain = couchbase::operations::rbac::auth_domain::external;
+        } else {
+            exc = rb_exc_new_str(eInvalidArgument, rb_sprintf("unsupported authentication domain: %+" PRIsVALUE, domain));
+            break;
+        }
+        req.username.assign(RSTRING_PTR(username), static_cast<size_t>(RSTRING_LEN(username)));
+        auto barrier = std::make_shared<std::promise<couchbase::operations::user_drop_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req,
+                                       [barrier](couchbase::operations::user_drop_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to fetch user "{}")", req.username).c_str());
+            break;
+        }
+
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_user_upsert(VALUE self, VALUE domain, VALUE user, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(domain, T_SYMBOL);
+    Check_Type(user, T_HASH);
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::user_upsert_request req{};
+        cb__extract_timeout(req, timeout);
+        if (domain == rb_id2sym(rb_intern("local"))) {
+            req.domain = couchbase::operations::rbac::auth_domain::local;
+        } else if (domain == rb_id2sym(rb_intern("external"))) {
+            req.domain = couchbase::operations::rbac::auth_domain::external;
+        } else {
+            exc = rb_exc_new_str(eInvalidArgument, rb_sprintf("unsupported authentication domain: %+" PRIsVALUE, domain));
+            break;
+        }
+        VALUE name = rb_hash_aref(user, rb_id2sym(rb_intern("username")));
+        if (NIL_P(name) || TYPE(name) != T_STRING) {
+            exc = rb_exc_new_cstr(eInvalidArgument, "unable to upsert user: missing name");
+        }
+        req.user.username.assign(RSTRING_PTR(name), static_cast<size_t>(RSTRING_LEN(name)));
+        VALUE display_name = rb_hash_aref(user, rb_id2sym(rb_intern("display_name")));
+        if (!NIL_P(display_name) && TYPE(display_name) == T_STRING) {
+            req.user.display_name = std::string(RSTRING_PTR(display_name), static_cast<size_t>(RSTRING_LEN(display_name)));
+        }
+        VALUE password = rb_hash_aref(user, rb_id2sym(rb_intern("password")));
+        if (!NIL_P(password) && TYPE(password) == T_STRING) {
+            req.user.password = std::string(RSTRING_PTR(password), static_cast<size_t>(RSTRING_LEN(password)));
+        }
+        VALUE groups = rb_hash_aref(user, rb_id2sym(rb_intern("groups")));
+        if (!NIL_P(groups) && TYPE(groups) == T_ARRAY) {
+            auto groups_size = static_cast<size_t>(RARRAY_LEN(groups));
+            for (size_t i = 0; i < groups_size; ++i) {
+                VALUE entry = rb_ary_entry(groups, static_cast<long>(i));
+                if (TYPE(entry) == T_STRING) {
+                    req.user.groups.emplace(std::string(RSTRING_PTR(entry), static_cast<size_t>(RSTRING_LEN(entry))));
+                }
+            }
+        }
+        VALUE roles = rb_hash_aref(user, rb_id2sym(rb_intern("roles")));
+        if (!NIL_P(roles) && TYPE(roles) == T_ARRAY) {
+            auto roles_size = static_cast<size_t>(RARRAY_LEN(roles));
+            req.user.roles.reserve(roles_size);
+            for (size_t i = 0; i < roles_size; ++i) {
+                VALUE entry = rb_ary_entry(roles, static_cast<long>(i));
+                if (TYPE(entry) == T_HASH) {
+                    couchbase::operations::rbac::role role{};
+                    VALUE role_name = rb_hash_aref(entry, rb_id2sym(rb_intern("name")));
+                    role.name.assign(RSTRING_PTR(role_name), static_cast<size_t>(RSTRING_LEN(role_name)));
+                    VALUE bucket = rb_hash_aref(entry, rb_id2sym(rb_intern("bucket")));
+                    if (!NIL_P(bucket) && TYPE(bucket) == T_STRING) {
+                        role.bucket = std::string(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
+                        VALUE scope = rb_hash_aref(entry, rb_id2sym(rb_intern("scope")));
+                        if (!NIL_P(scope) && TYPE(scope) == T_STRING) {
+                            role.scope = std::string(RSTRING_PTR(scope), static_cast<size_t>(RSTRING_LEN(scope)));
+                            VALUE collection = rb_hash_aref(entry, rb_id2sym(rb_intern("collection")));
+                            if (!NIL_P(collection) && TYPE(collection) == T_STRING) {
+                                role.collection = std::string(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
+                            }
+                        }
+                    }
+                    req.user.roles.emplace_back(role);
+                }
+            }
+        }
+
+        auto barrier = std::make_shared<std::promise<couchbase::operations::user_upsert_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req,
+                                       [barrier](couchbase::operations::user_upsert_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(
+              resp.ec, fmt::format(R"(unable to upsert user "{}" ({}))", req.user.username, fmt::join(resp.errors, ", ")).c_str());
+            break;
+        }
+
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static void
+cb__extract_group(const couchbase::operations::rbac::group& entry, VALUE group)
+{
+    rb_hash_aset(group, rb_id2sym(rb_intern("name")), rb_str_new(entry.name.data(), static_cast<long>(entry.name.size())));
+    if (entry.description) {
+        rb_hash_aset(
+          group, rb_id2sym(rb_intern("description")), rb_str_new(entry.description->data(), static_cast<long>(entry.description->size())));
+    }
+    if (entry.ldap_group_reference) {
+        rb_hash_aset(group,
+                     rb_id2sym(rb_intern("ldap_group_reference")),
+                     rb_str_new(entry.ldap_group_reference->data(), static_cast<long>(entry.ldap_group_reference->size())));
+    }
+    VALUE roles = rb_ary_new_capa(static_cast<long>(entry.roles.size()));
+    for (const auto& er : entry.roles) {
+        VALUE role = rb_hash_new();
+        rb_hash_aset(role, rb_id2sym(rb_intern("name")), rb_str_new(er.name.data(), static_cast<long>(er.name.size())));
+        if (er.bucket) {
+            rb_hash_aset(role, rb_id2sym(rb_intern("bucket")), rb_str_new(er.bucket->data(), static_cast<long>(er.bucket->size())));
+        }
+        if (er.scope) {
+            rb_hash_aset(role, rb_id2sym(rb_intern("scope")), rb_str_new(er.scope->data(), static_cast<long>(er.scope->size())));
+        }
+        if (er.collection) {
+            rb_hash_aset(
+              role, rb_id2sym(rb_intern("collection")), rb_str_new(er.collection->data(), static_cast<long>(er.collection->size())));
+        }
+        rb_ary_push(roles, role);
+    }
+    rb_hash_aset(group, rb_id2sym(rb_intern("roles")), roles);
+}
+
+static VALUE
+cb_Backend_group_get_all(VALUE self, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::group_get_all_request req{};
+        cb__extract_timeout(req, timeout);
+        auto barrier = std::make_shared<std::promise<couchbase::operations::group_get_all_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req,
+                                       [barrier](couchbase::operations::group_get_all_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, "unable to fetch groups");
+            break;
+        }
+
+        VALUE res = rb_ary_new_capa(static_cast<long>(resp.groups.size()));
+        for (const auto& entry : resp.groups) {
+            VALUE group = rb_hash_new();
+            cb__extract_group(entry, group);
+            rb_ary_push(res, group);
+        }
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_group_get(VALUE self, VALUE name, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(name, T_STRING);
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::group_get_request req{};
+        cb__extract_timeout(req, timeout);
+        req.name.assign(RSTRING_PTR(name), static_cast<size_t>(RSTRING_LEN(name)));
+        auto barrier = std::make_shared<std::promise<couchbase::operations::group_get_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req,
+                                       [barrier](couchbase::operations::group_get_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to fetch group "{}")", req.name).c_str());
+            break;
+        }
+
+        VALUE res = rb_hash_new();
+        cb__extract_group(resp.group, res);
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_group_drop(VALUE self, VALUE name, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(name, T_STRING);
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::group_drop_request req{};
+        cb__extract_timeout(req, timeout);
+        req.name.assign(RSTRING_PTR(name), static_cast<size_t>(RSTRING_LEN(name)));
+        auto barrier = std::make_shared<std::promise<couchbase::operations::group_drop_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req,
+                                       [barrier](couchbase::operations::group_drop_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to drop group "{}")", req.name).c_str());
+            break;
+        }
+
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_group_upsert(VALUE self, VALUE group, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(group, T_HASH);
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::group_upsert_request req{};
+        cb__extract_timeout(req, timeout);
+        VALUE name = rb_hash_aref(group, rb_id2sym(rb_intern("name")));
+        if (NIL_P(name) || TYPE(name) != T_STRING) {
+            exc = rb_exc_new_cstr(eInvalidArgument, "unable to upsert group: missing name");
+        }
+        req.group.name.assign(RSTRING_PTR(name), static_cast<size_t>(RSTRING_LEN(name)));
+        VALUE ldap_group_ref = rb_hash_aref(group, rb_id2sym(rb_intern("ldap_group_reference")));
+        if (!NIL_P(ldap_group_ref) && TYPE(ldap_group_ref) == T_STRING) {
+            req.group.ldap_group_reference = std::string(RSTRING_PTR(ldap_group_ref), static_cast<size_t>(RSTRING_LEN(ldap_group_ref)));
+        }
+        VALUE description = rb_hash_aref(group, rb_id2sym(rb_intern("description")));
+        if (!NIL_P(description) && TYPE(description) == T_STRING) {
+            req.group.description = std::string(RSTRING_PTR(description), static_cast<size_t>(RSTRING_LEN(description)));
+        }
+        VALUE roles = rb_hash_aref(group, rb_id2sym(rb_intern("roles")));
+        if (!NIL_P(roles) && TYPE(roles) == T_ARRAY) {
+            auto roles_size = static_cast<size_t>(RARRAY_LEN(roles));
+            req.group.roles.reserve(roles_size);
+            for (size_t i = 0; i < roles_size; ++i) {
+                VALUE entry = rb_ary_entry(roles, static_cast<long>(i));
+                if (TYPE(entry) == T_HASH) {
+                    couchbase::operations::rbac::role role{};
+                    VALUE role_name = rb_hash_aref(entry, rb_id2sym(rb_intern("name")));
+                    role.name.assign(RSTRING_PTR(role_name), static_cast<size_t>(RSTRING_LEN(role_name)));
+                    VALUE bucket = rb_hash_aref(entry, rb_id2sym(rb_intern("bucket")));
+                    if (!NIL_P(bucket) && TYPE(bucket) == T_STRING) {
+                        role.bucket = std::string(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
+                        VALUE scope = rb_hash_aref(entry, rb_id2sym(rb_intern("scope")));
+                        if (!NIL_P(scope) && TYPE(scope) == T_STRING) {
+                            role.scope = std::string(RSTRING_PTR(scope), static_cast<size_t>(RSTRING_LEN(scope)));
+                            VALUE collection = rb_hash_aref(entry, rb_id2sym(rb_intern("collection")));
+                            if (!NIL_P(collection) && TYPE(collection) == T_STRING) {
+                                role.collection = std::string(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
+                            }
+                        }
+                    }
+                    req.group.roles.emplace_back(role);
+                }
+            }
+        }
+        auto barrier = std::make_shared<std::promise<couchbase::operations::group_upsert_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req,
+                                       [barrier](couchbase::operations::group_upsert_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(
+              resp.ec, fmt::format(R"(unable to upsert group "{}" ({}))", req.group.name, fmt::join(resp.errors, ", ")).c_str());
+            break;
+        }
+
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
 static VALUE
 cb_Backend_cluster_enable_developer_preview(VALUE self)
 {
@@ -2629,6 +3370,58 @@ cb_Backend_scope_get_all(VALUE self, VALUE bucket_name, VALUE timeout)
     return Qnil;
 }
 
+static VALUE
+cb_Backend_collections_manifest_get(VALUE self, VALUE bucket_name, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(bucket_name, T_STRING);
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::collections_manifest_get_request req{};
+        cb__extract_timeout(req, timeout);
+        req.id.bucket.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        auto barrier = std::make_shared<std::promise<couchbase::operations::collections_manifest_get_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute(
+          req, [barrier](couchbase::operations::collections_manifest_get_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("unable to get collections manifest of the bucket \"{}\"", req.id.bucket));
+            break;
+        }
+
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("uid")), ULL2NUM(resp.manifest.uid));
+        VALUE scopes = rb_ary_new_capa(static_cast<long>(resp.manifest.scopes.size()));
+        for (const auto& s : resp.manifest.scopes) {
+            VALUE scope = rb_hash_new();
+            rb_hash_aset(scope, rb_id2sym(rb_intern("uid")), ULL2NUM(s.uid));
+            rb_hash_aset(scope, rb_id2sym(rb_intern("name")), rb_str_new(s.name.data(), static_cast<long>(s.name.size())));
+            VALUE collections = rb_ary_new_capa(static_cast<long>(s.collections.size()));
+            for (const auto& c : s.collections) {
+                VALUE collection = rb_hash_new();
+                rb_hash_aset(collection, rb_id2sym(rb_intern("uid")), ULL2NUM(c.uid));
+                rb_hash_aset(collection, rb_id2sym(rb_intern("name")), rb_str_new(c.name.data(), static_cast<long>(c.name.size())));
+                rb_ary_push(collections, collection);
+            }
+            rb_hash_aset(scope, rb_id2sym(rb_intern("collections")), collections);
+            rb_ary_push(scopes, scope);
+        }
+        rb_hash_aset(res, rb_id2sym(rb_intern("scopes")), scopes);
+
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
 static VALUE
 cb_Backend_scope_create(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE timeout)
 {
@@ -2654,7 +3447,8 @@ cb_Backend_scope_create(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE t
                                        [barrier](couchbase::operations::scope_create_response resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to create the scope on the bucket \"{}\"", req.bucket_name));
+            exc = cb__map_error_code(resp.ec,
+                                     fmt::format(R"(unable to create the scope "{}" on the bucket "{}")", req.scope_name, req.bucket_name));
             break;
         }
         return ULL2NUM(resp.uid);
@@ -3525,6 +4319,71 @@ cb_Backend_search_index_get_documents_count(VALUE self, VALUE index_name, VALUE
     return Qnil;
 }
 
+static VALUE
+cb_Backend_search_index_get_stats(VALUE self, VALUE index_name, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(index_name, T_STRING);
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::search_index_get_stats_request req{};
+        cb__extract_timeout(req, timeout);
+        req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
+        auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_get_stats_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::search_index_get_stats_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.error.empty()) {
+                exc = cb__map_error_code(resp.ec, fmt::format("unable to get stats for the search index \"{}\"", req.index_name));
+            } else {
+                exc = cb__map_error_code(resp.ec,
+                                         fmt::format("unable to get stats for the search index \"{}\": {}", req.index_name, resp.error));
+            }
+            break;
+        }
+        return rb_str_new(resp.stats.data(), static_cast<long>(resp.stats.size()));
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_search_get_stats(VALUE self, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::search_index_stats_request req{};
+        cb__extract_timeout(req, timeout);
+        auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_stats_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::search_index_stats_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, "unable to get stats for the search service");
+            break;
+        }
+        return rb_str_new(resp.stats.data(), static_cast<long>(resp.stats.size()));
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
 static VALUE
 cb_Backend_search_index_pause_ingest(VALUE self, VALUE index_name, VALUE timeout)
 {
@@ -3833,6 +4692,11 @@ cb_Backend_document_search(VALUE self, VALUE index_name, VALUE query, VALUE opti
             req.explain = RTEST(explain);
         }
 
+        VALUE disable_scoring = rb_hash_aref(options, rb_id2sym(rb_intern("disable_scoring")));
+        if (!NIL_P(disable_scoring)) {
+            req.disable_scoring = RTEST(disable_scoring);
+        }
+
         VALUE skip = rb_hash_aref(options, rb_id2sym(rb_intern("skip")));
         if (!NIL_P(skip)) {
             Check_Type(skip, T_FIXNUM);
@@ -3962,7 +4826,8 @@ cb_Backend_document_search(VALUE self, VALUE index_name, VALUE query, VALUE opti
         backend->cluster->execute_http(req, [barrier](couchbase::operations::search_response resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to perform search query for index \"{}\"", req.index_name));
+            exc =
+              cb__map_error_code(resp.ec, fmt::format("unable to perform search query for index \"{}\": {}", req.index_name, resp.error));
             break;
         }
         VALUE res = rb_hash_new();
@@ -5444,6 +6309,7 @@ init_backend(VALUE mCouchbase)
     rb_define_method(cBackend, "open", VALUE_FUNC(cb_Backend_open), 3);
     rb_define_method(cBackend, "close", VALUE_FUNC(cb_Backend_close), 0);
     rb_define_method(cBackend, "open_bucket", VALUE_FUNC(cb_Backend_open_bucket), 2);
+    rb_define_method(cBackend, "diagnostics", VALUE_FUNC(cb_Backend_diagnostics), 1);
 
     rb_define_method(cBackend, "document_get", VALUE_FUNC(cb_Backend_document_get), 4);
     rb_define_method(cBackend, "document_get_projected", VALUE_FUNC(cb_Backend_document_get_projected), 7);
@@ -5472,6 +6338,16 @@ init_backend(VALUE mCouchbase)
     rb_define_method(cBackend, "bucket_get_all", VALUE_FUNC(cb_Backend_bucket_get_all), 1);
     rb_define_method(cBackend, "bucket_get", VALUE_FUNC(cb_Backend_bucket_get), 2);
 
+    rb_define_method(cBackend, "role_get_all", VALUE_FUNC(cb_Backend_role_get_all), 1);
+    rb_define_method(cBackend, "user_get_all", VALUE_FUNC(cb_Backend_user_get_all), 2);
+    rb_define_method(cBackend, "user_get", VALUE_FUNC(cb_Backend_user_get), 3);
+    rb_define_method(cBackend, "user_drop", VALUE_FUNC(cb_Backend_user_drop), 3);
+    rb_define_method(cBackend, "user_upsert", VALUE_FUNC(cb_Backend_user_upsert), 3);
+    rb_define_method(cBackend, "group_get_all", VALUE_FUNC(cb_Backend_group_get_all), 1);
+    rb_define_method(cBackend, "group_get", VALUE_FUNC(cb_Backend_group_get), 2);
+    rb_define_method(cBackend, "group_drop", VALUE_FUNC(cb_Backend_group_drop), 2);
+    rb_define_method(cBackend, "group_upsert", VALUE_FUNC(cb_Backend_group_upsert), 2);
+
     rb_define_method(cBackend, "cluster_enable_developer_preview!", VALUE_FUNC(cb_Backend_cluster_enable_developer_preview), 0);
 
     rb_define_method(cBackend, "scope_get_all", VALUE_FUNC(cb_Backend_scope_get_all), 2);
@@ -5488,10 +6364,12 @@ init_backend(VALUE mCouchbase)
     rb_define_method(cBackend, "query_index_build_deferred", VALUE_FUNC(cb_Backend_query_index_build_deferred), 2);
     rb_define_method(cBackend, "query_index_watch", VALUE_FUNC(cb_Backend_query_index_watch), 4);
 
+    rb_define_method(cBackend, "search_get_stats", VALUE_FUNC(cb_Backend_search_get_stats), 1);
     rb_define_method(cBackend, "search_index_get_all", VALUE_FUNC(cb_Backend_search_index_get_all), 1);
     rb_define_method(cBackend, "search_index_get", VALUE_FUNC(cb_Backend_search_index_get), 2);
     rb_define_method(cBackend, "search_index_upsert", VALUE_FUNC(cb_Backend_search_index_upsert), 2);
     rb_define_method(cBackend, "search_index_drop", VALUE_FUNC(cb_Backend_search_index_drop), 2);
+    rb_define_method(cBackend, "search_index_get_stats", VALUE_FUNC(cb_Backend_search_index_get_stats), 2);
     rb_define_method(cBackend, "search_index_get_documents_count", VALUE_FUNC(cb_Backend_search_index_get_documents_count), 2);
     rb_define_method(cBackend, "search_index_pause_ingest", VALUE_FUNC(cb_Backend_search_index_pause_ingest), 2);
     rb_define_method(cBackend, "search_index_resume_ingest", VALUE_FUNC(cb_Backend_search_index_resume_ingest), 2);
@@ -5518,6 +6396,8 @@ init_backend(VALUE mCouchbase)
     rb_define_method(cBackend, "view_index_drop", VALUE_FUNC(cb_Backend_view_index_drop), 4);
     rb_define_method(cBackend, "view_index_upsert", VALUE_FUNC(cb_Backend_view_index_upsert), 4);
 
+    /* utility function that are not intended for public usage */
+    rb_define_method(cBackend, "collections_manifest_get", VALUE_FUNC(cb_Backend_collections_manifest_get), 2);
     rb_define_singleton_method(cBackend, "dns_srv", VALUE_FUNC(cb_Backend_dns_srv), 2);
     rb_define_singleton_method(cBackend, "parse_connection_string", VALUE_FUNC(cb_Backend_parse_connection_string), 1);
 }
@@ -5529,10 +6409,9 @@ init_logger()
 
     auto env_val = spdlog::details::os::getenv("COUCHBASE_BACKEND_LOG_LEVEL");
     if (env_val.empty()) {
-        spdlog::set_level(spdlog::level::warn);
+        spdlog::set_level(spdlog::level::info);
     } else {
-        auto levels = spdlog::cfg::helpers::extract_levels(env_val);
-        spdlog::details::registry::instance().update_levels(std::move(levels));
+        spdlog::cfg::helpers::load_levels(env_val);
     }
 
     couchbase::platform::install_backtrace_terminate_handler();