couchbase 3.1.1 → 3.2.0

data/ext/couchbase/cluster.hxx

@@ -17,9 +17,9 @@
 
 #pragma once
 
-#include <utility>
-#include <thread>
 #include <fstream>
+#include <thread>
+#include <utility>
 
 #include <asio/ssl.hpp>
 
@@ -32,6 +32,11 @@
 #include <operations.hxx>
 #include <operations/document_query.hxx>
 
+#include <tracing/noop_tracer.hxx>
+#include <tracing/threshold_logging_tracer.hxx>
+#include <metrics/noop_meter.hxx>
+#include <metrics/logging_meter.hxx>
+
 #include <diagnostics.hxx>
 
 namespace couchbase
@@ -88,12 +93,9 @@ class cluster
 {
   public:
     explicit cluster(asio::io_context& ctx)
-      : id_(uuid::to_string(uuid::random()))
-      , ctx_(ctx)
+      : ctx_(ctx)
       , work_(asio::make_work_guard(ctx_))
-      , tls_(asio::ssl::context::tls_client)
       , session_manager_(std::make_shared<io::http_session_manager>(id_, ctx_, tls_))
-      , dns_config_(io::dns::dns_config::get())
       , dns_client_(ctx_)
     {
     }
@@ -102,6 +104,17 @@ class cluster
     void open(const couchbase::origin& origin, Handler&& handler)
     {
         origin_ = origin;
+        if (origin_.options().enable_tracing) {
+            tracer_ = new tracing::threshold_logging_tracer(ctx_, origin.options().tracing_options);
+        } else {
+            tracer_ = new tracing::noop_tracer();
+        }
+        if (origin_.options().enable_metrics) {
+            meter_ = new metrics::logging_meter(ctx_, origin.options().metrics_options);
+        } else {
+            meter_ = new metrics::noop_meter();
+        }
+        session_manager_->set_tracer(tracer_);
         if (origin_.options().enable_dns_srv) {
             return asio::post(asio::bind_executor(
               ctx_, [this, handler = std::forward<Handler>(handler)]() mutable { return do_dns_srv(std::forward<Handler>(handler)); }));
@@ -122,21 +135,24 @@ class cluster
             session_manager_->close();
             handler();
             work_.reset();
+            delete tracer_;
+            tracer_ = nullptr;
+            delete meter_;
+            meter_ = nullptr;
         }));
     }
 
     template<typename Handler>
     void open_bucket(const std::string& bucket_name, Handler&& handler)
     {
-        auto ptr = buckets_.find(bucket_name);
-        if (ptr != buckets_.end()) {
+        if (buckets_.find(bucket_name) != buckets_.end()) {
             return handler({});
         }
         std::vector<protocol::hello_feature> known_features;
         if (session_ && session_->has_config()) {
             known_features = session_->supported_features();
         }
-        auto b = std::make_shared<bucket>(id_, ctx_, tls_, bucket_name, origin_, known_features);
+        auto b = std::make_shared<bucket>(id_, ctx_, tls_, tracer_, meter_, bucket_name, origin_, known_features);
         b->bootstrap([this, handler = std::forward<Handler>(handler)](std::error_code ec, const configuration& config) mutable {
             if (!ec && !session_->supports_gcccp()) {
                 session_manager_->set_configuration(config, origin_.options());
@@ -153,7 +169,7 @@ class cluster
         if (bucket == buckets_.end()) {
             error_context::key_value ctx{};
             ctx.id = request.id;
-            ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
+            ctx.ec = error::common_errc::bucket_not_found;
             using response_type = typename Request::encoded_response_type;
             return handler(operations::make_response(std::move(ctx), request, response_type{}));
         }
@@ -166,10 +182,10 @@ class cluster
         auto session = session_manager_->check_out(Request::type, origin_.credentials());
         if (!session) {
             typename Request::error_context_type ctx{};
-            ctx.ec = std::make_error_code(error::common_errc::service_not_available);
+            ctx.ec = error::common_errc::service_not_available;
             return handler(operations::make_response(std::move(ctx), request, {}));
         }
-        auto cmd = std::make_shared<operations::http_command<Request>>(ctx_, request);
+        auto cmd = std::make_shared<operations::http_command<Request>>(ctx_, request, tracer_, meter_);
         cmd->send_to(session, [this, session, handler = std::forward<Handler>(handler)](typename Request::response_type resp) mutable {
             handler(std::move(resp));
             session_manager_->check_in(Request::type, session);
@@ -185,10 +201,10 @@ class cluster
         asio::post(asio::bind_executor(ctx_, [this, report_id, handler = std::forward<Handler>(handler)]() mutable {
             diag::diagnostics_result res{ report_id.value(), couchbase::sdk_id() };
             if (session_) {
-                res.services[service_type::kv].emplace_back(session_->diag_info());
+                res.services[service_type::key_value].emplace_back(session_->diag_info());
             }
-            for (const auto& bucket : buckets_) {
-                bucket.second->export_diag_info(res);
+            for (const auto& [name, bucket] : buckets_) {
+                bucket->export_diag_info(res);
             }
             session_manager_->export_diag_info(res);
             handler(std::move(res));
@@ -204,19 +220,19 @@ class cluster
             report_id = std::make_optional(uuid::to_string(uuid::random()));
         }
         if (services.empty()) {
-            services = { service_type::kv, service_type::views, service_type::query, service_type::search, service_type::analytics };
+            services = { service_type::key_value, service_type::view, service_type::query, service_type::search, service_type::analytics };
         }
         asio::post(asio::bind_executor(ctx_, [this, report_id, bucket_name, services, handler = std::move(handler)]() mutable {
             auto collector = std::make_shared<ping_collector>(report_id.value(), std::move(handler));
             if (bucket_name) {
-                if (services.find(service_type::kv) != services.end()) {
+                if (services.find(service_type::key_value) != services.end()) {
                     auto bucket = buckets_.find(bucket_name.value());
                     if (bucket != buckets_.end()) {
                         bucket->second->ping(collector);
                     }
                 }
             } else {
-                if (services.find(service_type::kv) != services.end()) {
+                if (services.find(service_type::key_value) != services.end()) {
                     if (session_) {
                         session_->ping(collector->build_reporter());
                     }
@@ -322,7 +338,7 @@ class cluster
                     origin::node_list nodes;
                     nodes.reserve(config.nodes.size());
                     for (const auto& address : config.nodes) {
-                        auto port = address.port_or(origin_.options().network, service_type::kv, origin_.options().enable_tls, 0);
+                        auto port = address.port_or(origin_.options().network, service_type::key_value, origin_.options().enable_tls, 0);
                         if (port == 0) {
                             continue;
                         }
@@ -342,15 +358,17 @@ class cluster
         });
     }
 
-    std::string id_;
+    std::string id_{ uuid::to_string(uuid::random()) };
     asio::io_context& ctx_;
     asio::executor_work_guard<asio::io_context::executor_type> work_;
-    asio::ssl::context tls_;
+    asio::ssl::context tls_{ asio::ssl::context::tls_client };
     std::shared_ptr<io::http_session_manager> session_manager_;
-    io::dns::dns_config& dns_config_;
+    io::dns::dns_config& dns_config_{ io::dns::dns_config::get() };
     couchbase::io::dns::dns_client dns_client_;
     std::shared_ptr<io::mcbp_session> session_{};
     std::map<std::string, std::shared_ptr<bucket>> buckets_{};
     couchbase::origin origin_{};
+    tracing::request_tracer* tracer_{ nullptr };
+    metrics::meter* meter_{ nullptr };
 };
 } // namespace couchbase

data/ext/couchbase/cluster_options.hxx

@@ -18,6 +18,8 @@
 #pragma once
 
 #include <timeout_defaults.hxx>
+#include <tracing/threshold_logging_options.hxx>
+#include <metrics/logging_meter_options.hxx>
 
 namespace couchbase
 {
@@ -43,14 +45,18 @@ struct cluster_options {
     bool enable_unordered_execution{ true };
     bool enable_clustermap_notification{ true };
     bool enable_compression{ true };
+    bool enable_tracing{ true };
+    bool enable_metrics{ true };
     std::string network{ "auto" };
+    tracing::threshold_logging_options tracing_options{};
+    metrics::logging_meter_options metrics_options{};
 
     std::chrono::milliseconds tcp_keep_alive_interval = timeout_defaults::tcp_keep_alive_interval;
     std::chrono::milliseconds config_poll_interval = timeout_defaults::config_poll_interval;
     std::chrono::milliseconds config_poll_floor = timeout_defaults::config_poll_floor;
     std::chrono::milliseconds config_idle_redial_timeout = timeout_defaults::config_idle_redial_timeout;
 
-    size_t max_http_connections{ 0 };
+    std::size_t max_http_connections{ 0 };
     std::chrono::milliseconds idle_http_connection_timeout = timeout_defaults::idle_http_connection_timeout;
 };
 

data/ext/couchbase/configuration.hxx

@@ -21,13 +21,13 @@
 
 #include <gsl/gsl_util>
 
-#include <tao/json.hpp>
+#include <platform/uuid.h>
 #include <spdlog/spdlog.h>
+#include <tao/json.hpp>
 #include <utils/crc32.hxx>
-#include <platform/uuid.h>
 
-#include <service_type.hxx>
 #include <capabilities.hxx>
+#include <service_type.hxx>
 
 namespace couchbase
 {
@@ -73,13 +73,13 @@ struct configuration {
                     case service_type::search:
                         return services_tls.search.value_or(default_value);
 
-                    case service_type::views:
+                    case service_type::view:
                         return services_tls.views.value_or(default_value);
 
                     case service_type::management:
                         return services_tls.management.value_or(default_value);
 
-                    case service_type::kv:
+                    case service_type::key_value:
                         return services_tls.key_value.value_or(default_value);
                 }
             }
@@ -93,13 +93,13 @@ struct configuration {
                 case service_type::search:
                     return services_plain.search.value_or(default_value);
 
-                case service_type::views:
+                case service_type::view:
                     return services_plain.views.value_or(default_value);
 
                 case service_type::management:
                     return services_plain.management.value_or(default_value);
 
-                case service_type::kv:
+                case service_type::key_value:
                     return services_plain.key_value.value_or(default_value);
             }
             return default_value;
@@ -139,13 +139,13 @@ struct configuration {
                     case service_type::search:
                         return address->second.services_tls.search.value_or(default_value);
 
-                    case service_type::views:
+                    case service_type::view:
                         return address->second.services_tls.views.value_or(default_value);
 
                     case service_type::management:
                         return address->second.services_tls.management.value_or(default_value);
 
-                    case service_type::kv:
+                    case service_type::key_value:
                         return address->second.services_tls.key_value.value_or(default_value);
                 }
             }
@@ -159,13 +159,13 @@ struct configuration {
                 case service_type::search:
                     return address->second.services_plain.search.value_or(default_value);
 
-                case service_type::views:
+                case service_type::view:
                     return address->second.services_plain.views.value_or(default_value);
 
                 case service_type::management:
                     return address->second.services_plain.management.value_or(default_value);
 
-                case service_type::kv:
+                case service_type::key_value:
                     return address->second.services_plain.key_value.value_or(default_value);
             }
             return default_value;
@@ -191,7 +191,8 @@ struct configuration {
 
     using vbucket_map = typename std::vector<std::vector<std::int16_t>>;
 
-    std::optional<std::uint64_t> rev{};
+    std::optional<std::int64_t> epoch{};
+    std::optional<std::int64_t> rev{};
     couchbase::uuid::uuid_t id{};
     std::optional<std::uint32_t> num_replicas{};
     std::vector<node> nodes{};
@@ -203,8 +204,26 @@ struct configuration {
     std::set<cluster_capability> cluster_capabilities{};
     node_locator_type node_locator{ node_locator_type::unknown };
 
+    bool operator==(const configuration& other) const
+    {
+        return epoch == other.epoch && rev == other.rev;
+    }
+
+    bool operator<(const configuration& other) const
+    {
+        return epoch < other.epoch && rev < other.rev;
+    }
+
+    bool operator>(const configuration& other) const
+    {
+        return other < *this;
+    }
+
     [[nodiscard]] std::string rev_str() const
     {
+        if (epoch) {
+            return fmt::format("{}:{}", epoch.value(), rev.value_or(0));
+        }
         return rev ? fmt::format("{}", *rev) : "(none)";
     }
 
@@ -240,8 +259,8 @@ struct configuration {
             throw std::runtime_error("cannot map key: partition map is not available");
         }
         uint32_t crc = utils::hash_crc32(key.data(), key.size());
-        uint16_t vbucket = uint16_t(crc % vbmap->size());
-        return std::make_pair(vbucket, vbmap->at(vbucket)[0]);
+        auto vbucket = uint16_t(crc % vbmap->size());
+        return { vbucket, vbmap->at(vbucket)[0] };
     }
 };
 
@@ -250,6 +269,7 @@ make_blank_configuration(const std::string& hostname, std::uint16_t plain_port,
 {
     configuration result;
     result.id = couchbase::uuid::random();
+    result.epoch = 0;
     result.rev = 0;
     result.nodes.resize(1);
     result.nodes[0].hostname = hostname;
@@ -400,7 +420,8 @@ struct traits<couchbase::configuration> {
     {
         couchbase::configuration result;
         result.id = couchbase::uuid::random();
-        result.rev = v.template optional<std::uint64_t>("rev");
+        result.epoch = v.template optional<std::int64_t>("revEpoch");
+        result.rev = v.template optional<std::int64_t>("rev");
         auto* node_locator = v.find("nodeLocator");
         if (node_locator != nullptr && node_locator->is_string()) {
             if (node_locator->get_string() == "ketama") {
@@ -423,7 +444,7 @@ struct traits<couchbase::configuration> {
                 const auto& hostname = o.find("hostname");
                 if (hostname != o.end()) {
                     n.hostname = hostname->second.get_string();
-                    n.hostname = n.hostname.substr(0, n.hostname.rfind(":"));
+                    n.hostname = n.hostname.substr(0, n.hostname.rfind(':'));
                 }
                 const auto& s = o.at("services");
                 n.services_plain.key_value = s.template optional<std::uint16_t>("kv");

data/ext/couchbase/couchbase.cxx

@@ -57,6 +57,15 @@ cb_str_new(const std::string& str)
     return rb_external_str_new(str.data(), static_cast<long>(str.size()));
 }
 
+static inline VALUE
+cb_str_new(const std::optional<std::string>& str)
+{
+    if (str) {
+        return rb_external_str_new(str->data(), static_cast<long>(str->size()));
+    }
+    return Qnil;
+}
+
 static void
 init_versions(VALUE mCouchbase)
 {
@@ -97,11 +106,12 @@ init_versions(VALUE mCouchbase)
 #endif
 
     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))));
+    spdlog::debug("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_version")), rb_str_freeze(rb_str_new_cstr(CMAKE_VERSION)));
     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)));
@@ -235,6 +245,7 @@ static VALUE eInternalServerFailure;
 static VALUE eInvalidArgument;
 static VALUE eJobQueueFull;
 static VALUE eLinkNotFound;
+static VALUE eLinkExists;
 static VALUE eNumberTooBig;
 static VALUE eParsingFailure;
 static VALUE ePathExists;
@@ -317,6 +328,7 @@ init_exceptions(VALUE mCouchbase)
     eInvalidArgument = rb_define_class_under(mError, "InvalidArgument", rb_eArgError);
     eJobQueueFull = rb_define_class_under(mError, "JobQueueFull", eCouchbaseError);
     eLinkNotFound = rb_define_class_under(mError, "LinkNotFound", eCouchbaseError);
+    eLinkExists = rb_define_class_under(mError, "LinkExists", 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);
@@ -358,7 +370,7 @@ static VALUE
 cb_map_error_code(std::error_code ec, const std::string& message)
 {
     if (ec.category() == couchbase::error::detail::get_common_category()) {
-        switch (static_cast<couchbase::error::common_errc>(ec.value())) {
+        switch (couchbase::error::common_errc(ec.value())) {
             case couchbase::error::common_errc::unambiguous_timeout:
                 return rb_exc_new_cstr(eUnambiguousTimeout, fmt::format("{}: {}", message, ec.message()).c_str());
 
@@ -417,7 +429,7 @@ cb_map_error_code(std::error_code ec, const std::string& message)
                 return rb_exc_new_cstr(eIndexExists, fmt::format("{}: {}", message, ec.message()).c_str());
         }
     } else if (ec.category() == couchbase::error::detail::get_key_value_category()) {
-        switch (static_cast<couchbase::error::key_value_errc>(ec.value())) {
+        switch (couchbase::error::key_value_errc(ec.value())) {
             case couchbase::error::key_value_errc::document_not_found:
                 return rb_exc_new_cstr(eDocumentNotFound, fmt::format("{}: {}", message, ec.message()).c_str());
 
@@ -494,7 +506,7 @@ cb_map_error_code(std::error_code ec, const std::string& message)
                 return rb_exc_new_cstr(eXattrCannotModifyVirtualAttribute, fmt::format("{}: {}", message, ec.message()).c_str());
         }
     } else if (ec.category() == couchbase::error::detail::get_query_category()) {
-        switch (static_cast<couchbase::error::query_errc>(ec.value())) {
+        switch (couchbase::error::query_errc(ec.value())) {
             case couchbase::error::query_errc::planning_failure:
                 return rb_exc_new_cstr(ePlanningFailure, fmt::format("{}: {}", message, ec.message()).c_str());
 
@@ -505,14 +517,14 @@ cb_map_error_code(std::error_code ec, const std::string& message)
                 return rb_exc_new_cstr(ePreparedStatementFailure, fmt::format("{}: {}", message, ec.message()).c_str());
         }
     } else if (ec.category() == couchbase::error::detail::get_search_category()) {
-        switch (static_cast<couchbase::error::search_errc>(ec.value())) {
+        switch (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())) {
+        switch (couchbase::error::view_errc(ec.value())) {
             case couchbase::error::view_errc::view_not_found:
                 return rb_exc_new_cstr(eViewNotFound, fmt::format("{}: {}", message, ec.message()).c_str());
 
@@ -520,7 +532,7 @@ cb_map_error_code(std::error_code ec, const std::string& message)
                 return rb_exc_new_cstr(eDesignDocumentNotFound, fmt::format("{}: {}", message, ec.message()).c_str());
         }
     } else if (ec.category() == couchbase::error::detail::get_analytics_category()) {
-        switch (static_cast<couchbase::error::analytics_errc>(ec.value())) {
+        switch (couchbase::error::analytics_errc(ec.value())) {
             case couchbase::error::analytics_errc::compilation_failure:
                 return rb_exc_new_cstr(eCompilationFailure, fmt::format("{}: {}", message, ec.message()).c_str());
 
@@ -541,9 +553,12 @@ cb_map_error_code(std::error_code ec, const std::string& message)
 
             case couchbase::error::analytics_errc::link_not_found:
                 return rb_exc_new_cstr(eLinkNotFound, fmt::format("{}: {}", message, ec.message()).c_str());
+
+            case couchbase::error::analytics_errc::link_exists:
+                return rb_exc_new_cstr(eLinkExists, fmt::format("{}: {}", message, ec.message()).c_str());
         }
     } else if (ec.category() == couchbase::error::detail::get_management_category()) {
-        switch (static_cast<couchbase::error::management_errc>(ec.value())) {
+        switch (couchbase::error::management_errc(ec.value())) {
             case couchbase::error::management_errc::collection_exists:
                 return rb_exc_new_cstr(eCollectionExists, fmt::format("{}: {}", message, ec.message()).c_str());
 
@@ -566,7 +581,7 @@ cb_map_error_code(std::error_code ec, const std::string& message)
                 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())) {
+        switch (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());
 
@@ -836,6 +851,126 @@ cb_wait_for_future(Future&& f) -> decltype(f.get())
     return std::move(arg.res);
 }
 
+template<typename Request>
+[[nodiscard]] VALUE
+cb_extract_timeout(Request& req, VALUE options)
+{
+    if (!NIL_P(options)) {
+        switch (TYPE(options)) {
+            case T_HASH:
+                return cb_extract_timeout(req, rb_hash_aref(options, rb_id2sym(rb_intern("timeout"))));
+            case T_FIXNUM:
+            case T_BIGNUM:
+                req.timeout = std::chrono::milliseconds(NUM2ULL(options));
+                break;
+            default:
+                return rb_exc_new_str(rb_eArgError, rb_sprintf("timeout must be an Integer, but given %+" PRIsVALUE, options));
+        }
+    }
+    return Qnil;
+}
+
+[[nodiscard]] VALUE
+cb_extract_timeout(std::chrono::milliseconds& timeout, VALUE options)
+{
+    if (!NIL_P(options)) {
+        switch (TYPE(options)) {
+            case T_HASH:
+                return cb_extract_timeout(timeout, rb_hash_aref(options, rb_id2sym(rb_intern("timeout"))));
+            case T_FIXNUM:
+            case T_BIGNUM:
+                timeout = std::chrono::milliseconds(NUM2ULL(options));
+                break;
+            default:
+                return rb_exc_new_str(rb_eArgError, rb_sprintf("timeout must be an Integer, but given %+" PRIsVALUE, options));
+        }
+    }
+    return Qnil;
+}
+
+[[nodiscard]] VALUE
+cb_extract_option_bool(bool& field, VALUE options, const char* name)
+{
+    if (!NIL_P(options) && TYPE(options) == T_HASH) {
+        VALUE val = rb_hash_aref(options, rb_id2sym(rb_intern(name)));
+        if (NIL_P(val)) {
+            return Qnil;
+        }
+        switch (TYPE(val)) {
+            case T_TRUE:
+                field = true;
+                break;
+            case T_FALSE:
+                field = false;
+                break;
+            default:
+                return rb_exc_new_str(rb_eArgError, rb_sprintf("%s must be a Boolean, but given %+" PRIsVALUE, name, val));
+        }
+    }
+    return Qnil;
+}
+
+[[nodiscard]] VALUE
+cb_extract_option_number(std::size_t& field, VALUE options, const char* name)
+{
+    if (!NIL_P(options) && TYPE(options) == T_HASH) {
+        VALUE val = rb_hash_aref(options, rb_id2sym(rb_intern(name)));
+        if (NIL_P(val)) {
+            return Qnil;
+        }
+        switch (TYPE(val)) {
+            case T_FIXNUM:
+                field = FIX2ULONG(val);
+                break;
+            case T_BIGNUM:
+                field = NUM2ULL(val);
+                break;
+            default:
+                return rb_exc_new_str(rb_eArgError, rb_sprintf("%s must be a Integer, but given %+" PRIsVALUE, name, val));
+        }
+    }
+    return Qnil;
+}
+
+[[nodiscard]] VALUE
+cb_extract_option_milliseconds(std::chrono::milliseconds& field, VALUE options, const char* name)
+{
+    if (!NIL_P(options) && TYPE(options) == T_HASH) {
+        VALUE val = rb_hash_aref(options, rb_id2sym(rb_intern(name)));
+        if (NIL_P(val)) {
+            return Qnil;
+        }
+        switch (TYPE(val)) {
+            case T_FIXNUM:
+                field = std::chrono::milliseconds(FIX2ULONG(val));
+                break;
+            case T_BIGNUM:
+                field = std::chrono::milliseconds(NUM2ULL(val));
+                break;
+            default:
+                return rb_exc_new_str(rb_eArgError,
+                                      rb_sprintf("%s must be a Integer representing milliseconds, but given %+" PRIsVALUE, name, val));
+        }
+    }
+    return Qnil;
+}
+
+[[nodiscard]] VALUE
+cb_extract_option_array(VALUE& val, VALUE options, const char* name)
+{
+    if (!NIL_P(options) && TYPE(options) == T_HASH) {
+        val = rb_hash_aref(options, rb_id2sym(rb_intern(name)));
+        if (NIL_P(val)) {
+            return Qnil;
+        }
+        if (TYPE(val) == T_ARRAY) {
+            return Qnil;
+        }
+        return rb_exc_new_str(rb_eArgError, rb_sprintf("%s must be an Array, but given %+" PRIsVALUE, name, val));
+    }
+    return Qnil;
+}
+
 static VALUE
 cb_Backend_open(VALUE self, VALUE connection_string, VALUE credentials, VALUE options)
 {
@@ -880,21 +1015,28 @@ cb_Backend_open(VALUE self, VALUE connection_string, VALUE credentials, VALUE op
         if (NIL_P(certificate_path) || NIL_P(key_path)) {
             auth.username.assign(RSTRING_PTR(username), static_cast<size_t>(RSTRING_LEN(username)));
             auth.password.assign(RSTRING_PTR(password), static_cast<size_t>(RSTRING_LEN(password)));
-            VALUE allowed_mechanisms = rb_hash_aref(options, rb_id2sym(rb_intern("allowed_sasl_mechanisms")));
-            if (!NIL_P(allowed_mechanisms)) {
-                Check_Type(allowed_mechanisms, T_ARRAY);
-                auto allowed_mechanisms_size = static_cast<size_t>(RARRAY_LEN(allowed_mechanisms));
-                auth.allowed_sasl_mechanisms.reserve(allowed_mechanisms_size);
-                for (size_t i = 0; i < allowed_mechanisms_size; ++i) {
-                    VALUE mechanism = rb_ary_entry(allowed_mechanisms, static_cast<long>(i));
-                    if (mechanism == rb_id2sym(rb_intern("scram_sha512"))) {
-                        auth.allowed_sasl_mechanisms.emplace_back("SCRAM-SHA512");
-                    } else if (mechanism == rb_id2sym(rb_intern("scram_sha256"))) {
-                        auth.allowed_sasl_mechanisms.emplace_back("SCRAM-SHA256");
-                    } else if (mechanism == rb_id2sym(rb_intern("scram_sha1"))) {
-                        auth.allowed_sasl_mechanisms.emplace_back("SCRAM-SHA1");
-                    } else if (mechanism == rb_id2sym(rb_intern("plain"))) {
-                        auth.allowed_sasl_mechanisms.emplace_back("PLAIN");
+            if (!NIL_P(options)) {
+                VALUE allowed_mechanisms = rb_hash_aref(options, rb_id2sym(rb_intern("allowed_sasl_mechanisms")));
+                if (!NIL_P(allowed_mechanisms)) {
+                    Check_Type(allowed_mechanisms, T_ARRAY);
+                    auto allowed_mechanisms_size = static_cast<size_t>(RARRAY_LEN(allowed_mechanisms));
+                    if (allowed_mechanisms_size < 1) {
+                        exc = rb_exc_new_cstr(eInvalidArgument, "allowed_sasl_mechanisms list cannot be empty");
+                        break;
+                    }
+                    auth.allowed_sasl_mechanisms.clear();
+                    auth.allowed_sasl_mechanisms.reserve(allowed_mechanisms_size);
+                    for (size_t i = 0; i < allowed_mechanisms_size; ++i) {
+                        VALUE mechanism = rb_ary_entry(allowed_mechanisms, static_cast<long>(i));
+                        if (mechanism == rb_id2sym(rb_intern("scram_sha512"))) {
+                            auth.allowed_sasl_mechanisms.emplace_back("SCRAM-SHA512");
+                        } else if (mechanism == rb_id2sym(rb_intern("scram_sha256"))) {
+                            auth.allowed_sasl_mechanisms.emplace_back("SCRAM-SHA256");
+                        } else if (mechanism == rb_id2sym(rb_intern("scram_sha1"))) {
+                            auth.allowed_sasl_mechanisms.emplace_back("SCRAM-SHA1");
+                        } else if (mechanism == rb_id2sym(rb_intern("plain"))) {
+                            auth.allowed_sasl_mechanisms.emplace_back("PLAIN");
+                        }
                     }
                 }
             }
@@ -909,6 +1051,66 @@ cb_Backend_open(VALUE self, VALUE connection_string, VALUE credentials, VALUE op
             auth.key_path.assign(RSTRING_PTR(key_path), static_cast<size_t>(RSTRING_LEN(key_path)));
         }
         couchbase::origin origin(auth, connstr);
+        exc = cb_extract_option_bool(origin.options().enable_tracing, options, "enable_tracing");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        if (origin.options().enable_tracing) {
+            exc =
+              cb_extract_option_milliseconds(origin.options().tracing_options.orphaned_emit_interval, options, "orphaned_emit_interval");
+            if (!NIL_P(exc)) {
+                break;
+            }
+            exc = cb_extract_option_number(origin.options().tracing_options.orphaned_sample_size, options, "orphaned_sample_size");
+            if (!NIL_P(exc)) {
+                break;
+            }
+
+            exc =
+              cb_extract_option_milliseconds(origin.options().tracing_options.threshold_emit_interval, options, "threshold_emit_interval");
+            if (!NIL_P(exc)) {
+                break;
+            }
+            exc = cb_extract_option_number(origin.options().tracing_options.threshold_sample_size, options, "threshold_sample_size");
+            if (!NIL_P(exc)) {
+                break;
+            }
+            exc = cb_extract_option_milliseconds(origin.options().tracing_options.key_value_threshold, options, "key_value_threshold");
+            if (!NIL_P(exc)) {
+                break;
+            }
+            exc = cb_extract_option_milliseconds(origin.options().tracing_options.query_threshold, options, "query_threshold");
+            if (!NIL_P(exc)) {
+                break;
+            }
+            exc = cb_extract_option_milliseconds(origin.options().tracing_options.view_threshold, options, "view_threshold");
+            if (!NIL_P(exc)) {
+                break;
+            }
+            exc = cb_extract_option_milliseconds(origin.options().tracing_options.search_threshold, options, "search_threshold");
+            if (!NIL_P(exc)) {
+                break;
+            }
+            exc = cb_extract_option_milliseconds(origin.options().tracing_options.analytics_threshold, options, "analytics_threshold");
+            if (!NIL_P(exc)) {
+                break;
+            }
+            exc = cb_extract_option_milliseconds(origin.options().tracing_options.management_threshold, options, "management_threshold");
+            if (!NIL_P(exc)) {
+                break;
+            }
+        }
+        exc = cb_extract_option_bool(origin.options().enable_metrics, options, "enable_metrics");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        if (origin.options().enable_metrics) {
+            exc = cb_extract_option_milliseconds(origin.options().metrics_options.emit_interval, options, "metrics_emit_interval");
+            if (!NIL_P(exc)) {
+                break;
+            }
+        }
+
         auto barrier = std::make_shared<std::promise<std::error_code>>();
         auto f = barrier->get_future();
         backend->cluster->open(origin, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
@@ -966,7 +1168,7 @@ cb_Backend_diagnostics(VALUE self, VALUE report_id)
         for (const auto& svcs : resp.services) {
             VALUE type = Qnil;
             switch (svcs.first) {
-                case couchbase::service_type::kv:
+                case couchbase::service_type::key_value:
                     type = rb_id2sym(rb_intern("kv"));
                     break;
                 case couchbase::service_type::query:
@@ -978,7 +1180,7 @@ cb_Backend_diagnostics(VALUE self, VALUE report_id)
                 case couchbase::service_type::search:
                     type = rb_id2sym(rb_intern("search"));
                     break;
-                case couchbase::service_type::views:
+                case couchbase::service_type::view:
                     type = rb_id2sym(rb_intern("views"));
                     break;
                 case couchbase::service_type::management:
@@ -1059,81 +1261,6 @@ cb_Backend_open_bucket(VALUE self, VALUE bucket, VALUE wait_until_ready)
     return Qnil;
 }
 
-template<typename Request>
-[[nodiscard]] VALUE
-cb_extract_timeout(Request& req, VALUE options)
-{
-    if (!NIL_P(options)) {
-        switch (TYPE(options)) {
-            case T_HASH:
-                return cb_extract_timeout(req, rb_hash_aref(options, rb_id2sym(rb_intern("timeout"))));
-            case T_FIXNUM:
-            case T_BIGNUM:
-                req.timeout = std::chrono::milliseconds(NUM2ULL(options));
-                break;
-            default:
-                return rb_exc_new_str(rb_eArgError, rb_sprintf("timeout must be an Integer, but given %+" PRIsVALUE, options));
-        }
-    }
-    return Qnil;
-}
-
-[[nodiscard]] VALUE
-cb_extract_timeout(std::chrono::milliseconds& timeout, VALUE options)
-{
-    if (!NIL_P(options)) {
-        switch (TYPE(options)) {
-            case T_HASH:
-                return cb_extract_timeout(timeout, rb_hash_aref(options, rb_id2sym(rb_intern("timeout"))));
-            case T_FIXNUM:
-            case T_BIGNUM:
-                timeout = std::chrono::milliseconds(NUM2ULL(options));
-                break;
-            default:
-                return rb_exc_new_str(rb_eArgError, rb_sprintf("timeout must be an Integer, but given %+" PRIsVALUE, options));
-        }
-    }
-    return Qnil;
-}
-
-[[nodiscard]] VALUE
-cb_extract_option_bool(bool& field, VALUE options, const char* name)
-{
-    if (!NIL_P(options) && TYPE(options) == T_HASH) {
-        VALUE val = rb_hash_aref(options, rb_id2sym(rb_intern(name)));
-        if (NIL_P(val)) {
-            return Qnil;
-        }
-        switch (TYPE(val)) {
-            case T_TRUE:
-                field = true;
-                break;
-            case T_FALSE:
-                field = false;
-                break;
-            default:
-                return rb_exc_new_str(rb_eArgError, rb_sprintf("%s must be a Boolean, but given %+" PRIsVALUE, name, val));
-        }
-    }
-    return Qnil;
-}
-
-[[nodiscard]] VALUE
-cb_extract_option_array(VALUE& val, VALUE options, const char* name)
-{
-    if (!NIL_P(options) && TYPE(options) == T_HASH) {
-        val = rb_hash_aref(options, rb_id2sym(rb_intern(name)));
-        if (NIL_P(val)) {
-            return Qnil;
-        }
-        if (TYPE(val) == T_ARRAY) {
-            return Qnil;
-        }
-        return rb_exc_new_str(rb_eArgError, rb_sprintf("%s must be an Array, but given %+" PRIsVALUE, name, val));
-    }
-    return Qnil;
-}
-
 [[nodiscard]] VALUE
 cb_extract_array_of_ids(std::vector<couchbase::document_id>& ids, VALUE arg)
 {
@@ -1189,7 +1316,7 @@ cb_extract_array_of_id_content(std::vector<std::tuple<couchbase::document_id, st
         if (TYPE(entry) != T_ARRAY || RARRAY_LEN(entry) != 5) {
             return rb_exc_new_str(
               rb_eArgError,
-              rb_sprintf("ID/content tuple must be represented as an Array[bucket, collection, id, content], but given %+" PRIsVALUE,
+              rb_sprintf("ID/content tuple must be represented as an Array[bucket, collection, id, content, flags], but given %+" PRIsVALUE,
                          entry));
         }
         VALUE bucket = rb_ary_entry(entry, 0);
@@ -1268,13 +1395,12 @@ cb_extract_array_of_id_cas(std::vector<std::pair<couchbase::document_id, std::ui
             }
         }
 
-        id_cas.emplace_back(std::make_pair(
-          couchbase::document_id{
-            std::string(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket))),
-            std::string(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection))),
-            std::string(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id))),
-          },
-          cas_val));
+        id_cas.emplace_back(std::pair{ couchbase::document_id{
+                                         std::string(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket))),
+                                         std::string(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection))),
+                                         std::string(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id))),
+                                       },
+                                       cas_val });
     }
 
     return Qnil;
@@ -1313,37 +1439,71 @@ cb_extract_option_string(VALUE& val, VALUE options, const char* name)
 }
 
 [[nodiscard]] VALUE
-cb_extract_option_fixnum(VALUE& val, VALUE options, const char* name)
+cb_extract_option_string(std::string& target, VALUE options, const char* name)
 {
     if (!NIL_P(options) && TYPE(options) == T_HASH) {
-        val = rb_hash_aref(options, rb_id2sym(rb_intern(name)));
+        VALUE val = rb_hash_aref(options, rb_id2sym(rb_intern(name)));
         if (NIL_P(val)) {
             return Qnil;
         }
-        if (TYPE(val) == T_FIXNUM) {
+        if (TYPE(val) == T_STRING) {
+            target.assign(RSTRING_PTR(val), static_cast<size_t>(RSTRING_LEN(val)));
             return Qnil;
         }
-        return rb_exc_new_str(rb_eArgError, rb_sprintf("%s must be an Integer, but given %+" PRIsVALUE, name, val));
+        return rb_exc_new_str(rb_eArgError, rb_sprintf("%s must be an String, but given %+" PRIsVALUE, name, val));
     }
     return Qnil;
 }
 
 [[nodiscard]] VALUE
-cb_extract_option_bignum(VALUE& val, VALUE options, const char* name)
+cb_extract_option_string(std::optional<std::string>& target, VALUE options, const char* name)
 {
     if (!NIL_P(options) && TYPE(options) == T_HASH) {
-        val = rb_hash_aref(options, rb_id2sym(rb_intern(name)));
+        VALUE val = rb_hash_aref(options, rb_id2sym(rb_intern(name)));
         if (NIL_P(val)) {
             return Qnil;
         }
-        switch (TYPE(val)) {
-            case T_FIXNUM:
-            case T_BIGNUM:
-                return Qnil;
-            default:
-                break;
+        if (TYPE(val) == T_STRING) {
+            target.emplace(std::string(RSTRING_PTR(val), static_cast<size_t>(RSTRING_LEN(val))));
+            return Qnil;
         }
-        return rb_exc_new_str(rb_eArgError, rb_sprintf("%s must be an Integer, but given %+" PRIsVALUE, name, val));
+        return rb_exc_new_str(rb_eArgError, rb_sprintf("%s must be an String, but given %+" PRIsVALUE, name, val));
+    }
+    return Qnil;
+}
+
+[[nodiscard]] VALUE
+cb_extract_option_fixnum(VALUE& val, VALUE options, const char* name)
+{
+    if (!NIL_P(options) && TYPE(options) == T_HASH) {
+        val = rb_hash_aref(options, rb_id2sym(rb_intern(name)));
+        if (NIL_P(val)) {
+            return Qnil;
+        }
+        if (TYPE(val) == T_FIXNUM) {
+            return Qnil;
+        }
+        return rb_exc_new_str(rb_eArgError, rb_sprintf("%s must be an Integer, but given %+" PRIsVALUE, name, val));
+    }
+    return Qnil;
+}
+
+[[nodiscard]] VALUE
+cb_extract_option_bignum(VALUE& val, VALUE options, const char* name)
+{
+    if (!NIL_P(options) && TYPE(options) == T_HASH) {
+        val = rb_hash_aref(options, rb_id2sym(rb_intern(name)));
+        if (NIL_P(val)) {
+            return Qnil;
+        }
+        switch (TYPE(val)) {
+            case T_FIXNUM:
+            case T_BIGNUM:
+                return Qnil;
+            default:
+                break;
+        }
+        return rb_exc_new_str(rb_eArgError, rb_sprintf("%s must be an Integer, but given %+" PRIsVALUE, name, val));
     }
     return Qnil;
 }
@@ -1432,7 +1592,7 @@ cb_Backend_ping(VALUE self, VALUE bucket, VALUE options)
             for (size_t i = 0; i < entries_num; ++i) {
                 VALUE entry = rb_ary_entry(services, static_cast<long>(i));
                 if (entry == rb_id2sym(rb_intern("kv"))) {
-                    selected_services.insert(couchbase::service_type::kv);
+                    selected_services.insert(couchbase::service_type::key_value);
                 } else if (entry == rb_id2sym(rb_intern("query"))) {
                     selected_services.insert(couchbase::service_type::query);
                 } else if (entry == rb_id2sym(rb_intern("analytics"))) {
@@ -1440,7 +1600,7 @@ cb_Backend_ping(VALUE self, VALUE bucket, VALUE options)
                 } else if (entry == rb_id2sym(rb_intern("search"))) {
                     selected_services.insert(couchbase::service_type::search);
                 } else if (entry == rb_id2sym(rb_intern("views"))) {
-                    selected_services.insert(couchbase::service_type::views);
+                    selected_services.insert(couchbase::service_type::view);
                 }
             }
         }
@@ -1459,7 +1619,7 @@ cb_Backend_ping(VALUE self, VALUE bucket, VALUE options)
         for (const auto& svcs : resp.services) {
             VALUE type = Qnil;
             switch (svcs.first) {
-                case couchbase::service_type::kv:
+                case couchbase::service_type::key_value:
                     type = rb_id2sym(rb_intern("kv"));
                     break;
                 case couchbase::service_type::query:
@@ -1471,7 +1631,7 @@ cb_Backend_ping(VALUE self, VALUE bucket, VALUE options)
                 case couchbase::service_type::search:
                     type = rb_id2sym(rb_intern("search"));
                     break;
-                case couchbase::service_type::views:
+                case couchbase::service_type::view:
                     type = rb_id2sym(rb_intern("views"));
                     break;
                 case couchbase::service_type::management:
@@ -3516,7 +3676,7 @@ cb_generate_bucket_settings(VALUE bucket, couchbase::operations::bucket_settings
 }
 
 static VALUE
-cb_Backend_bucket_create(VALUE self, VALUE bucket_settings, VALUE timeout)
+cb_Backend_bucket_create(VALUE self, VALUE bucket_settings, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -3527,11 +3687,14 @@ cb_Backend_bucket_create(VALUE self, VALUE bucket_settings, VALUE timeout)
     }
 
     Check_Type(bucket_settings, T_HASH);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::bucket_create_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
@@ -3557,7 +3720,7 @@ cb_Backend_bucket_create(VALUE self, VALUE bucket_settings, VALUE timeout)
 }
 
 static VALUE
-cb_Backend_bucket_update(VALUE self, VALUE bucket_settings, VALUE timeout)
+cb_Backend_bucket_update(VALUE self, VALUE bucket_settings, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -3568,10 +3731,13 @@ cb_Backend_bucket_update(VALUE self, VALUE bucket_settings, VALUE timeout)
     }
 
     Check_Type(bucket_settings, T_HASH);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
     VALUE exc = Qnil;
     do {
         couchbase::operations::bucket_update_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
@@ -3596,7 +3762,7 @@ cb_Backend_bucket_update(VALUE self, VALUE bucket_settings, VALUE timeout)
 }
 
 static VALUE
-cb_Backend_bucket_drop(VALUE self, VALUE bucket_name, VALUE timeout)
+cb_Backend_bucket_drop(VALUE self, VALUE bucket_name, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -3607,11 +3773,14 @@ cb_Backend_bucket_drop(VALUE self, VALUE bucket_name, VALUE timeout)
     }
 
     Check_Type(bucket_name, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::bucket_drop_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
@@ -3632,7 +3801,7 @@ cb_Backend_bucket_drop(VALUE self, VALUE bucket_name, VALUE timeout)
 }
 
 static VALUE
-cb_Backend_bucket_flush(VALUE self, VALUE bucket_name, VALUE timeout)
+cb_Backend_bucket_flush(VALUE self, VALUE bucket_name, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -3643,11 +3812,14 @@ cb_Backend_bucket_flush(VALUE self, VALUE bucket_name, VALUE timeout)
     }
 
     Check_Type(bucket_name, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::bucket_flush_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
@@ -3768,7 +3940,7 @@ cb_extract_bucket_settings(const couchbase::operations::bucket_settings& entry,
 }
 
 static VALUE
-cb_Backend_bucket_get_all(VALUE self, VALUE timeout)
+cb_Backend_bucket_get_all(VALUE self, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -3778,10 +3950,14 @@ cb_Backend_bucket_get_all(VALUE self, VALUE timeout)
         return Qnil;
     }
 
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
+
     VALUE exc = Qnil;
     do {
         couchbase::operations::bucket_get_all_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
@@ -3809,7 +3985,7 @@ cb_Backend_bucket_get_all(VALUE self, VALUE timeout)
 }
 
 static VALUE
-cb_Backend_bucket_get(VALUE self, VALUE bucket_name, VALUE timeout)
+cb_Backend_bucket_get(VALUE self, VALUE bucket_name, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -3820,11 +3996,14 @@ cb_Backend_bucket_get(VALUE self, VALUE bucket_name, VALUE timeout)
     }
 
     Check_Type(bucket_name, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::bucket_get_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
@@ -4475,7 +4654,7 @@ cb_Backend_cluster_enable_developer_preview(VALUE self)
 }
 
 static VALUE
-cb_Backend_scope_get_all(VALUE self, VALUE bucket_name, VALUE timeout)
+cb_Backend_scope_get_all(VALUE self, VALUE bucket_name, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -4486,11 +4665,14 @@ cb_Backend_scope_get_all(VALUE self, VALUE bucket_name, VALUE timeout)
     }
 
     Check_Type(bucket_name, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::scope_get_all_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
@@ -4587,7 +4769,7 @@ cb_Backend_collections_manifest_get(VALUE self, VALUE bucket_name, VALUE timeout
 }
 
 static VALUE
-cb_Backend_scope_create(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE timeout)
+cb_Backend_scope_create(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -4599,11 +4781,14 @@ cb_Backend_scope_create(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE t
 
     Check_Type(bucket_name, T_STRING);
     Check_Type(scope_name, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::scope_create_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
@@ -4626,7 +4811,7 @@ cb_Backend_scope_create(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE t
 }
 
 static VALUE
-cb_Backend_scope_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE timeout)
+cb_Backend_scope_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -4638,11 +4823,14 @@ cb_Backend_scope_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE tim
 
     Check_Type(bucket_name, T_STRING);
     Check_Type(scope_name, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::scope_drop_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
@@ -4665,7 +4853,7 @@ cb_Backend_scope_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE tim
 }
 
 static VALUE
-cb_Backend_collection_create(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE collection_name, VALUE max_expiry, VALUE timeout)
+cb_Backend_collection_create(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE collection_name, VALUE max_expiry, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -4678,11 +4866,14 @@ cb_Backend_collection_create(VALUE self, VALUE bucket_name, VALUE scope_name, VA
     Check_Type(bucket_name, T_STRING);
     Check_Type(scope_name, T_STRING);
     Check_Type(collection_name, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::collection_create_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
@@ -4713,7 +4904,7 @@ cb_Backend_collection_create(VALUE self, VALUE bucket_name, VALUE scope_name, VA
 }
 
 static VALUE
-cb_Backend_collection_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE collection_name, VALUE timeout)
+cb_Backend_collection_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE collection_name, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -4726,11 +4917,14 @@ cb_Backend_collection_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALU
     Check_Type(bucket_name, T_STRING);
     Check_Type(scope_name, T_STRING);
     Check_Type(collection_name, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::collection_drop_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
@@ -4757,7 +4951,7 @@ cb_Backend_collection_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALU
 }
 
 static VALUE
-cb_Backend_query_index_get_all(VALUE self, VALUE bucket_name, VALUE timeout)
+cb_Backend_query_index_get_all(VALUE self, VALUE bucket_name, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -4768,11 +4962,14 @@ cb_Backend_query_index_get_all(VALUE self, VALUE bucket_name, VALUE timeout)
     }
 
     Check_Type(bucket_name, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::query_index_get_all_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
@@ -4814,6 +5011,9 @@ cb_Backend_query_index_get_all(VALUE self, VALUE bucket_name, VALUE timeout)
             if (idx.condition) {
                 rb_hash_aset(index, rb_id2sym(rb_intern("condition")), cb_str_new(idx.condition.value()));
             }
+            if (idx.partition) {
+                rb_hash_aset(index, rb_id2sym(rb_intern("partition")), cb_str_new(idx.partition.value()));
+            }
             rb_ary_push(indexes, index);
         }
 
@@ -4826,7 +5026,7 @@ cb_Backend_query_index_get_all(VALUE self, VALUE bucket_name, VALUE timeout)
 }
 
 static VALUE
-cb_Backend_query_index_create(VALUE self, VALUE bucket_name, VALUE index_name, VALUE fields, VALUE options, VALUE timeout)
+cb_Backend_query_index_create(VALUE self, VALUE bucket_name, VALUE index_name, VALUE fields, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -4839,11 +5039,14 @@ cb_Backend_query_index_create(VALUE self, VALUE bucket_name, VALUE index_name, V
     Check_Type(bucket_name, T_STRING);
     Check_Type(index_name, T_STRING);
     Check_Type(fields, T_ARRAY);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::query_index_create_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
@@ -4857,7 +5060,6 @@ cb_Backend_query_index_create(VALUE self, VALUE bucket_name, VALUE index_name, V
             req.fields.emplace_back(RSTRING_PTR(entry), static_cast<std::size_t>(RSTRING_LEN(entry)));
         }
         if (!NIL_P(options)) {
-            Check_Type(options, T_HASH);
             VALUE ignore_if_exists = rb_hash_aref(options, rb_id2sym(rb_intern("ignore_if_exists")));
             if (ignore_if_exists == Qtrue) {
                 req.ignore_if_exists = true;
@@ -4927,7 +5129,7 @@ cb_Backend_query_index_create(VALUE self, VALUE bucket_name, VALUE index_name, V
 }
 
 static VALUE
-cb_Backend_query_index_drop(VALUE self, VALUE bucket_name, VALUE index_name, VALUE options, VALUE timeout)
+cb_Backend_query_index_drop(VALUE self, VALUE bucket_name, VALUE index_name, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -4939,18 +5141,20 @@ cb_Backend_query_index_drop(VALUE self, VALUE bucket_name, VALUE index_name, VAL
 
     Check_Type(bucket_name, T_STRING);
     Check_Type(index_name, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::query_index_drop_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
         req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
         req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
         if (!NIL_P(options)) {
-            Check_Type(options, T_HASH);
             VALUE ignore_if_does_not_exist = rb_hash_aref(options, rb_id2sym(rb_intern("ignore_if_does_not_exist")));
             if (ignore_if_does_not_exist == Qtrue) {
                 req.ignore_if_does_not_exist = true;
@@ -5006,7 +5210,7 @@ cb_Backend_query_index_drop(VALUE self, VALUE bucket_name, VALUE index_name, VAL
 }
 
 static VALUE
-cb_Backend_query_index_create_primary(VALUE self, VALUE bucket_name, VALUE options, VALUE timeout)
+cb_Backend_query_index_create_primary(VALUE self, VALUE bucket_name, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -5024,14 +5228,13 @@ cb_Backend_query_index_create_primary(VALUE self, VALUE bucket_name, VALUE optio
     VALUE exc = Qnil;
     do {
         couchbase::operations::query_index_create_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
         req.is_primary = true;
         req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
         if (!NIL_P(options)) {
-            Check_Type(options, T_HASH);
             VALUE ignore_if_exists = rb_hash_aref(options, rb_id2sym(rb_intern("ignore_if_exists")));
             if (ignore_if_exists == Qtrue) {
                 req.ignore_if_exists = true;
@@ -5100,7 +5303,7 @@ cb_Backend_query_index_create_primary(VALUE self, VALUE bucket_name, VALUE optio
 }
 
 static VALUE
-cb_Backend_query_index_drop_primary(VALUE self, VALUE bucket_name, VALUE options, VALUE timeout)
+cb_Backend_query_index_drop_primary(VALUE self, VALUE bucket_name, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -5111,18 +5314,20 @@ cb_Backend_query_index_drop_primary(VALUE self, VALUE bucket_name, VALUE options
     }
 
     Check_Type(bucket_name, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::query_index_drop_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
         req.is_primary = true;
         req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
         if (!NIL_P(options)) {
-            Check_Type(options, T_HASH);
             VALUE ignore_if_does_not_exist = rb_hash_aref(options, rb_id2sym(rb_intern("ignore_if_does_not_exist")));
             if (ignore_if_does_not_exist == Qtrue) {
                 req.ignore_if_does_not_exist = true;
@@ -5181,7 +5386,7 @@ cb_Backend_query_index_drop_primary(VALUE self, VALUE bucket_name, VALUE options
 }
 
 static VALUE
-cb_Backend_query_index_build_deferred(VALUE self, VALUE bucket_name, VALUE timeout)
+cb_Backend_query_index_build_deferred(VALUE self, VALUE bucket_name, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -5192,11 +5397,14 @@ cb_Backend_query_index_build_deferred(VALUE self, VALUE bucket_name, VALUE timeo
     }
 
     Check_Type(bucket_name, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::query_index_build_deferred_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
@@ -5273,7 +5481,7 @@ cb_extract_search_index(VALUE index, const couchbase::operations::search_index&
 }
 
 static VALUE
-cb_Backend_search_index_get_all(VALUE self, VALUE timeout)
+cb_Backend_search_index_get_all(VALUE self, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -5286,7 +5494,7 @@ cb_Backend_search_index_get_all(VALUE self, VALUE timeout)
     VALUE exc = Qnil;
     do {
         couchbase::operations::search_index_get_all_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
@@ -5922,7 +6130,9 @@ cb_Backend_document_search(VALUE self, VALUE index_name, VALUE query, VALUE opti
 
     Check_Type(index_name, T_STRING);
     Check_Type(query, T_STRING);
-    Check_Type(options, T_HASH);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
@@ -6041,6 +6251,22 @@ cb_Backend_document_search(VALUE self, VALUE index_name, VALUE query, VALUE opti
             }
         }
 
+        VALUE scope_name = rb_hash_aref(options, rb_id2sym(rb_intern("scope_name")));
+        if (!NIL_P(scope_name) && TYPE(scope_name) == T_STRING) {
+            req.scope_name.emplace(std::string(RSTRING_PTR(scope_name), static_cast<std::size_t>(RSTRING_LEN(scope_name))));
+            VALUE collections = rb_hash_aref(options, rb_id2sym(rb_intern("collections")));
+            if (!NIL_P(collections)) {
+                Check_Type(collections, T_ARRAY);
+                auto collections_size = static_cast<size_t>(RARRAY_LEN(collections));
+                req.collections.reserve(collections_size);
+                for (size_t i = 0; i < collections_size; ++i) {
+                    VALUE collection = rb_ary_entry(collections, static_cast<long>(i));
+                    Check_Type(collection, T_STRING);
+                    req.collections.emplace_back(std::string(RSTRING_PTR(collection), static_cast<std::size_t>(RSTRING_LEN(collection))));
+                }
+            }
+        }
+
         VALUE sort = rb_hash_aref(options, rb_id2sym(rb_intern("sort")));
         if (!NIL_P(sort)) {
             Check_Type(sort, T_ARRAY);
@@ -6271,7 +6497,7 @@ cb_Backend_dns_srv(VALUE self, VALUE hostname, VALUE service)
 }
 
 static VALUE
-cb_Backend_analytics_get_pending_mutations(VALUE self, VALUE timeout)
+cb_Backend_analytics_get_pending_mutations(VALUE self, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -6284,7 +6510,7 @@ cb_Backend_analytics_get_pending_mutations(VALUE self, VALUE timeout)
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_get_pending_mutations_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
@@ -6315,7 +6541,7 @@ cb_Backend_analytics_get_pending_mutations(VALUE self, VALUE timeout)
 }
 
 static VALUE
-cb_Backend_analytics_dataset_get_all(VALUE self, VALUE timeout)
+cb_Backend_analytics_dataset_get_all(VALUE self, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -6328,7 +6554,7 @@ cb_Backend_analytics_dataset_get_all(VALUE self, VALUE timeout)
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_dataset_get_all_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
@@ -6363,7 +6589,7 @@ cb_Backend_analytics_dataset_get_all(VALUE self, VALUE timeout)
 }
 
 static VALUE
-cb_Backend_analytics_dataset_drop(VALUE self, VALUE dataset_name, VALUE dataverse_name, VALUE ignore_if_does_not_exist, VALUE timeout)
+cb_Backend_analytics_dataset_drop(VALUE self, VALUE dataset_name, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -6374,23 +6600,26 @@ cb_Backend_analytics_dataset_drop(VALUE self, VALUE dataset_name, VALUE datavers
     }
 
     Check_Type(dataset_name, T_STRING);
-    if (!NIL_P(dataverse_name)) {
-        Check_Type(dataverse_name, T_STRING);
-    }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_dataset_drop_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
         req.dataset_name.assign(RSTRING_PTR(dataset_name), static_cast<size_t>(RSTRING_LEN(dataset_name)));
+        VALUE dataverse_name = Qnil;
+        exc = cb_extract_option_string(dataverse_name, options, "dataverse_name");
+        if (!NIL_P(exc)) {
+            break;
+        }
         if (!NIL_P(dataverse_name)) {
             req.dataverse_name.assign(RSTRING_PTR(dataverse_name), static_cast<size_t>(RSTRING_LEN(dataverse_name)));
         }
-        if (!NIL_P(ignore_if_does_not_exist)) {
-            req.ignore_if_does_not_exist = RTEST(ignore_if_does_not_exist);
+        exc = cb_extract_option_bool(req.ignore_if_does_not_exist, options, "ignore_if_does_not_exist");
+        if (!NIL_P(exc)) {
+            break;
         }
         auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_dataset_drop_response>>();
         auto f = barrier->get_future();
@@ -6418,13 +6647,7 @@ cb_Backend_analytics_dataset_drop(VALUE self, VALUE dataset_name, VALUE datavers
 }
 
 static VALUE
-cb_Backend_analytics_dataset_create(VALUE self,
-                                    VALUE dataset_name,
-                                    VALUE bucket_name,
-                                    VALUE condition,
-                                    VALUE dataverse_name,
-                                    VALUE ignore_if_exists,
-                                    VALUE timeout)
+cb_Backend_analytics_dataset_create(VALUE self, VALUE dataset_name, VALUE bucket_name, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -6436,30 +6659,35 @@ cb_Backend_analytics_dataset_create(VALUE self,
 
     Check_Type(dataset_name, T_STRING);
     Check_Type(bucket_name, T_STRING);
-    if (!NIL_P(condition)) {
-        Check_Type(condition, T_STRING);
-    }
-    if (!NIL_P(dataverse_name)) {
-        Check_Type(dataverse_name, T_STRING);
-    }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_dataset_create_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
         req.dataset_name.assign(RSTRING_PTR(dataset_name), static_cast<size_t>(RSTRING_LEN(dataset_name)));
         req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        VALUE condition = Qnil;
+        exc = cb_extract_option_string(condition, options, "condition");
+        if (!NIL_P(exc)) {
+            break;
+        }
         if (!NIL_P(condition)) {
             req.condition.emplace(std::string(RSTRING_PTR(condition), static_cast<size_t>(RSTRING_LEN(condition))));
         }
+        VALUE dataverse_name = Qnil;
+        exc = cb_extract_option_string(dataverse_name, options, "dataverse_name");
+        if (!NIL_P(exc)) {
+            break;
+        }
         if (!NIL_P(dataverse_name)) {
             req.dataverse_name.assign(RSTRING_PTR(dataverse_name), static_cast<size_t>(RSTRING_LEN(dataverse_name)));
         }
-        if (!NIL_P(ignore_if_exists)) {
-            req.ignore_if_exists = RTEST(ignore_if_exists);
+        exc = cb_extract_option_bool(req.ignore_if_exists, options, "ignore_if_exists");
+        if (!NIL_P(exc)) {
+            break;
         }
         auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_dataset_create_response>>();
         auto f = barrier->get_future();
@@ -6487,7 +6715,7 @@ cb_Backend_analytics_dataset_create(VALUE self,
 }
 
 static VALUE
-cb_Backend_analytics_dataverse_drop(VALUE self, VALUE dataverse_name, VALUE ignore_if_does_not_exist, VALUE timeout)
+cb_Backend_analytics_dataverse_drop(VALUE self, VALUE dataverse_name, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -6502,11 +6730,12 @@ cb_Backend_analytics_dataverse_drop(VALUE self, VALUE dataverse_name, VALUE igno
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_dataverse_drop_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
         req.dataverse_name.assign(RSTRING_PTR(dataverse_name), static_cast<size_t>(RSTRING_LEN(dataverse_name)));
+        VALUE ignore_if_does_not_exist = rb_hash_aref(options, rb_id2sym(rb_intern("ignore_if_does_not_exist")));
         if (!NIL_P(ignore_if_does_not_exist)) {
             req.ignore_if_does_not_exist = RTEST(ignore_if_does_not_exist);
         }
@@ -6533,7 +6762,7 @@ cb_Backend_analytics_dataverse_drop(VALUE self, VALUE dataverse_name, VALUE igno
 }
 
 static VALUE
-cb_Backend_analytics_dataverse_create(VALUE self, VALUE dataverse_name, VALUE ignore_if_exists, VALUE timeout)
+cb_Backend_analytics_dataverse_create(VALUE self, VALUE dataverse_name, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -6551,11 +6780,12 @@ cb_Backend_analytics_dataverse_create(VALUE self, VALUE dataverse_name, VALUE ig
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_dataverse_create_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
         req.dataverse_name.assign(RSTRING_PTR(dataverse_name), static_cast<size_t>(RSTRING_LEN(dataverse_name)));
+        VALUE ignore_if_exists = rb_hash_aref(options, rb_id2sym(rb_intern("ignore_if_exists")));
         if (!NIL_P(ignore_if_exists)) {
             req.ignore_if_exists = RTEST(ignore_if_exists);
         }
@@ -6582,7 +6812,7 @@ cb_Backend_analytics_dataverse_create(VALUE self, VALUE dataverse_name, VALUE ig
 }
 
 static VALUE
-cb_Backend_analytics_index_get_all(VALUE self, VALUE timeout)
+cb_Backend_analytics_index_get_all(VALUE self, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -6595,7 +6825,7 @@ cb_Backend_analytics_index_get_all(VALUE self, VALUE timeout)
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_index_get_all_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
@@ -6630,13 +6860,7 @@ cb_Backend_analytics_index_get_all(VALUE self, VALUE timeout)
 }
 
 static VALUE
-cb_Backend_analytics_index_create(VALUE self,
-                                  VALUE index_name,
-                                  VALUE dataset_name,
-                                  VALUE fields,
-                                  VALUE dataverse_name,
-                                  VALUE ignore_if_exists,
-                                  VALUE timeout)
+cb_Backend_analytics_index_create(VALUE self, VALUE index_name, VALUE dataset_name, VALUE fields, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -6649,14 +6873,11 @@ cb_Backend_analytics_index_create(VALUE self,
     Check_Type(index_name, T_STRING);
     Check_Type(dataset_name, T_STRING);
     Check_Type(fields, T_ARRAY);
-    if (!NIL_P(dataverse_name)) {
-        Check_Type(dataverse_name, T_STRING);
-    }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_index_create_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
@@ -6669,15 +6890,22 @@ cb_Backend_analytics_index_create(VALUE self,
             if (RARRAY_LEN(entry) == 2) {
                 VALUE field = rb_ary_entry(entry, 0);
                 VALUE type = rb_ary_entry(entry, 1);
-                req.fields.emplace(std::string(RSTRING_PTR(field), static_cast<std::size_t>(RSTRING_LEN(field))),
-                                   std::string(RSTRING_PTR(type), static_cast<std::size_t>(RSTRING_LEN(type))));
+                req.fields.try_emplace(std::string(RSTRING_PTR(field), static_cast<std::size_t>(RSTRING_LEN(field))),
+                                       std::string(RSTRING_PTR(type), static_cast<std::size_t>(RSTRING_LEN(type))));
             }
         }
+
+        VALUE dataverse_name = Qnil;
+        exc = cb_extract_option_string(dataverse_name, options, "dataverse_name");
+        if (!NIL_P(exc)) {
+            break;
+        }
         if (!NIL_P(dataverse_name)) {
             req.dataverse_name.assign(RSTRING_PTR(dataverse_name), static_cast<size_t>(RSTRING_LEN(dataverse_name)));
         }
-        if (!NIL_P(ignore_if_exists)) {
-            req.ignore_if_exists = RTEST(ignore_if_exists);
+        exc = cb_extract_option_bool(req.ignore_if_exists, options, "ignore_if_exists");
+        if (!NIL_P(exc)) {
+            break;
         }
         auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_index_create_response>>();
         auto f = barrier->get_future();
@@ -6707,12 +6935,7 @@ cb_Backend_analytics_index_create(VALUE self,
 }
 
 static VALUE
-cb_Backend_analytics_index_drop(VALUE self,
-                                VALUE index_name,
-                                VALUE dataset_name,
-                                VALUE dataverse_name,
-                                VALUE ignore_if_does_not_exist,
-                                VALUE timeout)
+cb_Backend_analytics_index_drop(VALUE self, VALUE index_name, VALUE dataset_name, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -6724,24 +6947,27 @@ cb_Backend_analytics_index_drop(VALUE self,
 
     Check_Type(index_name, T_STRING);
     Check_Type(dataset_name, T_STRING);
-    if (!NIL_P(dataverse_name)) {
-        Check_Type(dataverse_name, T_STRING);
-    }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_index_drop_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
         req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
         req.dataset_name.assign(RSTRING_PTR(dataset_name), static_cast<size_t>(RSTRING_LEN(dataset_name)));
+        VALUE dataverse_name = Qnil;
+        exc = cb_extract_option_string(dataverse_name, options, "dataverse_name");
+        if (!NIL_P(exc)) {
+            break;
+        }
         if (!NIL_P(dataverse_name)) {
             req.dataverse_name.assign(RSTRING_PTR(dataverse_name), static_cast<size_t>(RSTRING_LEN(dataverse_name)));
         }
-        if (!NIL_P(ignore_if_does_not_exist)) {
-            req.ignore_if_does_not_exist = RTEST(ignore_if_does_not_exist);
+        exc = cb_extract_option_bool(req.ignore_if_does_not_exist, options, "ignore_if_does_not_exist");
+        if (!NIL_P(exc)) {
+            break;
         }
         auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_index_drop_response>>();
         auto f = barrier->get_future();
@@ -6771,7 +6997,7 @@ cb_Backend_analytics_index_drop(VALUE self,
 }
 
 static VALUE
-cb_Backend_analytics_link_connect(VALUE self, VALUE link_name, VALUE force, VALUE dataverse_name, VALUE timeout)
+cb_Backend_analytics_link_connect(VALUE self, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -6781,24 +7007,32 @@ cb_Backend_analytics_link_connect(VALUE self, VALUE link_name, VALUE force, VALU
         return Qnil;
     }
 
-    Check_Type(link_name, T_STRING);
-    if (!NIL_P(dataverse_name)) {
-        Check_Type(dataverse_name, T_STRING);
-    }
-
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_link_connect_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+        VALUE link_name = Qnil;
+        exc = cb_extract_option_string(link_name, options, "link_name");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        if (!NIL_P(link_name)) {
+            req.link_name.assign(RSTRING_PTR(link_name), static_cast<size_t>(RSTRING_LEN(link_name)));
+        }
+        VALUE dataverse_name = Qnil;
+        exc = cb_extract_option_string(link_name, options, "dataverse_name");
         if (!NIL_P(exc)) {
             break;
         }
-        req.link_name.assign(RSTRING_PTR(link_name), static_cast<size_t>(RSTRING_LEN(link_name)));
         if (!NIL_P(dataverse_name)) {
             req.dataverse_name.assign(RSTRING_PTR(dataverse_name), static_cast<size_t>(RSTRING_LEN(dataverse_name)));
         }
-        if (!NIL_P(force)) {
-            req.force = RTEST(force);
+        exc = cb_extract_option_bool(req.force, options, "force");
+        if (!NIL_P(exc)) {
+            break;
         }
         auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_link_connect_response>>();
         auto f = barrier->get_future();
@@ -6826,7 +7060,7 @@ cb_Backend_analytics_link_connect(VALUE self, VALUE link_name, VALUE force, VALU
 }
 
 static VALUE
-cb_Backend_analytics_link_disconnect(VALUE self, VALUE link_name, VALUE dataverse_name, VALUE timeout)
+cb_Backend_analytics_link_disconnect(VALUE self, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -6836,19 +7070,26 @@ cb_Backend_analytics_link_disconnect(VALUE self, VALUE link_name, VALUE datavers
         return Qnil;
     }
 
-    Check_Type(link_name, T_STRING);
-    if (!NIL_P(dataverse_name)) {
-        Check_Type(dataverse_name, T_STRING);
-    }
-
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_link_disconnect_request req{};
-        exc = cb_extract_timeout(req, timeout);
+        exc = cb_extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+        VALUE link_name = Qnil;
+        exc = cb_extract_option_string(link_name, options, "link_name");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        if (!NIL_P(link_name)) {
+            req.link_name.assign(RSTRING_PTR(link_name), static_cast<size_t>(RSTRING_LEN(link_name)));
+        }
+        VALUE dataverse_name = Qnil;
+        exc = cb_extract_option_string(link_name, options, "dataverse_name");
         if (!NIL_P(exc)) {
             break;
         }
-        req.link_name.assign(RSTRING_PTR(link_name), static_cast<size_t>(RSTRING_LEN(link_name)));
         if (!NIL_P(dataverse_name)) {
             req.dataverse_name.assign(RSTRING_PTR(dataverse_name), static_cast<size_t>(RSTRING_LEN(dataverse_name)));
         }
@@ -6877,42 +7118,606 @@ cb_Backend_analytics_link_disconnect(VALUE self, VALUE link_name, VALUE datavers
     return Qnil;
 }
 
-static int
-cb_for_each_named_param_analytics(VALUE key, VALUE value, VALUE arg)
-{
-    auto* preq = reinterpret_cast<couchbase::operations::analytics_request*>(arg);
-    Check_Type(key, T_STRING);
-    Check_Type(value, T_STRING);
-    preq->named_parameters.emplace(
-      std::string_view(RSTRING_PTR(key), static_cast<std::size_t>(RSTRING_LEN(key))),
-      tao::json::from_string(std::string_view(RSTRING_PTR(value), static_cast<std::size_t>(RSTRING_LEN(value)))));
-    return ST_CONTINUE;
-}
-
 static VALUE
-cb_Backend_document_analytics(VALUE self, VALUE statement, VALUE options)
+cb_fill_link(couchbase::operations::analytics_link::couchbase_remote& dst, VALUE src)
 {
-    cb_backend_data* backend = nullptr;
-    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+    VALUE exc = Qnil;
 
-    if (!backend->cluster) {
-        rb_raise(rb_eArgError, "Cluster has been closed already");
-        return Qnil;
+    exc = cb_extract_option_string(dst.link_name, src, "link_name");
+    if (!NIL_P(exc)) {
+        return exc;
     }
-
-    Check_Type(statement, T_STRING);
-    Check_Type(options, T_HASH);
-
-    VALUE exc = Qnil;
-    do {
-        couchbase::operations::analytics_request req;
-        req.statement.assign(RSTRING_PTR(statement), static_cast<size_t>(RSTRING_LEN(statement)));
-        VALUE client_context_id = rb_hash_aref(options, rb_id2sym(rb_intern("client_context_id")));
-        if (!NIL_P(client_context_id)) {
-            Check_Type(client_context_id, T_STRING);
-            req.client_context_id.assign(RSTRING_PTR(client_context_id), static_cast<size_t>(RSTRING_LEN(client_context_id)));
-        }
-        exc = cb_extract_timeout(req, options);
+    exc = cb_extract_option_string(dst.dataverse, src, "dataverse");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    exc = cb_extract_option_string(dst.hostname, src, "hostname");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    exc = cb_extract_option_string(dst.username, src, "username");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    exc = cb_extract_option_string(dst.password, src, "password");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    VALUE encryption_level = Qnil;
+    exc = cb_extract_option_symbol(encryption_level, src, "encryption_level");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    if (NIL_P(encryption_level)) {
+        encryption_level = rb_id2sym(rb_intern("none"));
+    }
+    ID level = rb_sym2id(encryption_level);
+    if (level == rb_intern("none")) {
+        dst.encryption.level = couchbase::operations::analytics_link::encryption_level::none;
+    } else if (level == rb_intern("half")) {
+        dst.encryption.level = couchbase::operations::analytics_link::encryption_level::half;
+    } else if (level == rb_intern("full")) {
+        dst.encryption.level = couchbase::operations::analytics_link::encryption_level::full;
+    }
+    exc = cb_extract_option_string(dst.encryption.certificate, src, "certificate");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    exc = cb_extract_option_string(dst.encryption.client_certificate, src, "client_certificate");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    exc = cb_extract_option_string(dst.encryption.client_key, src, "client_key");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    return Qnil;
+}
+
+static VALUE
+cb_fill_link(couchbase::operations::analytics_link::azure_blob_external& dst, VALUE src)
+{
+    VALUE exc = Qnil;
+
+    exc = cb_extract_option_string(dst.link_name, src, "link_name");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    exc = cb_extract_option_string(dst.dataverse, src, "dataverse");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    exc = cb_extract_option_string(dst.connection_string, src, "connection_string");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    exc = cb_extract_option_string(dst.account_name, src, "account_name");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    exc = cb_extract_option_string(dst.account_key, src, "account_key");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    exc = cb_extract_option_string(dst.shared_access_signature, src, "shared_access_signature");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    exc = cb_extract_option_string(dst.blob_endpoint, src, "blob_endpoint");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    exc = cb_extract_option_string(dst.endpoint_suffix, src, "endpoint_suffix");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    return Qnil;
+}
+
+static VALUE
+cb_fill_link(couchbase::operations::analytics_link::s3_external& dst, VALUE src)
+{
+    VALUE exc = Qnil;
+
+    exc = cb_extract_option_string(dst.link_name, src, "link_name");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    exc = cb_extract_option_string(dst.dataverse, src, "dataverse");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    exc = cb_extract_option_string(dst.access_key_id, src, "access_key_id");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    exc = cb_extract_option_string(dst.secret_access_key, src, "secret_access_key");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    exc = cb_extract_option_string(dst.session_token, src, "session_token");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    exc = cb_extract_option_string(dst.region, src, "region");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    exc = cb_extract_option_string(dst.service_endpoint, src, "service_endpoint");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_analytics_link_create(VALUE self, VALUE link, VALUE options)
+{
+    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");
+        return Qnil;
+    }
+
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
+
+    VALUE exc = Qnil;
+    do {
+        VALUE link_type = Qnil;
+        exc = cb_extract_option_symbol(link_type, link, "type");
+        if (!NIL_P(exc)) {
+            return exc;
+        }
+
+        ID type = rb_sym2id(link_type);
+        if (type == rb_intern("couchbase")) {
+            couchbase::operations::analytics_link_create_request<couchbase::operations::analytics_link::couchbase_remote> req{};
+            exc = cb_extract_timeout(req, options);
+            if (!NIL_P(exc)) {
+                break;
+            }
+            exc = cb_fill_link(req.link, link);
+            if (!NIL_P(exc)) {
+                break;
+            }
+
+            auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_link_create_response>>();
+            auto f = barrier->get_future();
+            backend->cluster->execute_http(
+              req, [barrier](couchbase::operations::analytics_link_create_response&& resp) mutable { barrier->set_value(resp); });
+            auto resp = cb_wait_for_future(f);
+
+            if (resp.ctx.ec) {
+                if (resp.errors.empty()) {
+                    exc = cb_map_error_code(
+                      resp.ctx, fmt::format("unable to create couchbase_remote link `{}` on `{}`", req.link.link_name, req.link.dataverse));
+                } else {
+                    const auto& first_error = resp.errors.front();
+                    exc = cb_map_error_code(resp.ctx,
+                                            fmt::format("unable to create couchbase_remote link `{}` on `{}` ({}: {})",
+                                                        req.link.link_name,
+                                                        req.link.dataverse,
+                                                        first_error.code,
+                                                        first_error.message));
+                }
+                break;
+            }
+
+        } else if (type == rb_intern("azureblob")) {
+            couchbase::operations::analytics_link_create_request<couchbase::operations::analytics_link::azure_blob_external> req{};
+            exc = cb_extract_timeout(req, options);
+            if (!NIL_P(exc)) {
+                break;
+            }
+
+            exc = cb_fill_link(req.link, link);
+            if (!NIL_P(exc)) {
+                break;
+            }
+
+            auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_link_create_response>>();
+            auto f = barrier->get_future();
+            backend->cluster->execute_http(
+              req, [barrier](couchbase::operations::analytics_link_create_response&& resp) mutable { barrier->set_value(resp); });
+            auto resp = cb_wait_for_future(f);
+
+            if (resp.ctx.ec) {
+                if (resp.errors.empty()) {
+                    exc = cb_map_error_code(
+                      resp.ctx,
+                      fmt::format("unable to create azure_blob_external link `{}` on `{}`", req.link.link_name, req.link.dataverse));
+                } else {
+                    const auto& first_error = resp.errors.front();
+                    exc = cb_map_error_code(resp.ctx,
+                                            fmt::format("unable to create azure_blob_external link `{}` on `{}` ({}: {})",
+                                                        req.link.link_name,
+                                                        req.link.dataverse,
+                                                        first_error.code,
+                                                        first_error.message));
+                }
+                break;
+            }
+
+        } else if (type == rb_intern("s3")) {
+            couchbase::operations::analytics_link_create_request<couchbase::operations::analytics_link::s3_external> req{};
+            exc = cb_extract_timeout(req, options);
+            if (!NIL_P(exc)) {
+                break;
+            }
+
+            exc = cb_fill_link(req.link, link);
+            if (!NIL_P(exc)) {
+                break;
+            }
+
+            auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_link_create_response>>();
+            auto f = barrier->get_future();
+            backend->cluster->execute_http(
+              req, [barrier](couchbase::operations::analytics_link_create_response&& resp) mutable { barrier->set_value(resp); });
+            auto resp = cb_wait_for_future(f);
+
+            if (resp.ctx.ec) {
+                if (resp.errors.empty()) {
+                    exc = cb_map_error_code(
+                      resp.ctx, fmt::format("unable to create s3_external link `{}` on `{}`", req.link.link_name, req.link.dataverse));
+                } else {
+                    const auto& first_error = resp.errors.front();
+                    exc = cb_map_error_code(resp.ctx,
+                                            fmt::format("unable to create s3_external link `{}` on `{}` ({}: {})",
+                                                        req.link.link_name,
+                                                        req.link.dataverse,
+                                                        first_error.code,
+                                                        first_error.message));
+                }
+                break;
+            }
+        }
+
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_analytics_link_replace(VALUE self, VALUE link, VALUE options)
+{
+    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");
+        return Qnil;
+    }
+
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
+
+    VALUE exc = Qnil;
+    do {
+        VALUE link_type = Qnil;
+        exc = cb_extract_option_symbol(link_type, link, "type");
+        if (!NIL_P(exc)) {
+            return exc;
+        }
+
+        ID type = rb_sym2id(link_type);
+        if (type == rb_intern("couchbase")) {
+            couchbase::operations::analytics_link_replace_request<couchbase::operations::analytics_link::couchbase_remote> req{};
+            exc = cb_extract_timeout(req, options);
+            if (!NIL_P(exc)) {
+                break;
+            }
+            exc = cb_fill_link(req.link, link);
+            if (!NIL_P(exc)) {
+                break;
+            }
+
+            auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_link_replace_response>>();
+            auto f = barrier->get_future();
+            backend->cluster->execute_http(
+              req, [barrier](couchbase::operations::analytics_link_replace_response&& resp) mutable { barrier->set_value(resp); });
+            auto resp = cb_wait_for_future(f);
+
+            if (resp.ctx.ec) {
+                if (resp.errors.empty()) {
+                    exc = cb_map_error_code(
+                      resp.ctx,
+                      fmt::format("unable to replace couchbase_remote link `{}` on `{}`", req.link.link_name, req.link.dataverse));
+                } else {
+                    const auto& first_error = resp.errors.front();
+                    exc = cb_map_error_code(resp.ctx,
+                                            fmt::format("unable to replace couchbase_remote link `{}` on `{}` ({}: {})",
+                                                        req.link.link_name,
+                                                        req.link.dataverse,
+                                                        first_error.code,
+                                                        first_error.message));
+                }
+                break;
+            }
+
+        } else if (type == rb_intern("azureblob")) {
+            couchbase::operations::analytics_link_replace_request<couchbase::operations::analytics_link::azure_blob_external> req{};
+            exc = cb_extract_timeout(req, options);
+            if (!NIL_P(exc)) {
+                break;
+            }
+
+            exc = cb_fill_link(req.link, link);
+            if (!NIL_P(exc)) {
+                break;
+            }
+
+            auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_link_replace_response>>();
+            auto f = barrier->get_future();
+            backend->cluster->execute_http(
+              req, [barrier](couchbase::operations::analytics_link_replace_response&& resp) mutable { barrier->set_value(resp); });
+            auto resp = cb_wait_for_future(f);
+
+            if (resp.ctx.ec) {
+                if (resp.errors.empty()) {
+                    exc = cb_map_error_code(
+                      resp.ctx,
+                      fmt::format("unable to replace azure_blob_external link `{}` on `{}`", req.link.link_name, req.link.dataverse));
+                } else {
+                    const auto& first_error = resp.errors.front();
+                    exc = cb_map_error_code(resp.ctx,
+                                            fmt::format("unable to replace azure_blob_external link `{}` on `{}` ({}: {})",
+                                                        req.link.link_name,
+                                                        req.link.dataverse,
+                                                        first_error.code,
+                                                        first_error.message));
+                }
+                break;
+            }
+
+        } else if (type == rb_intern("s3")) {
+            couchbase::operations::analytics_link_replace_request<couchbase::operations::analytics_link::s3_external> req{};
+            exc = cb_extract_timeout(req, options);
+            if (!NIL_P(exc)) {
+                break;
+            }
+
+            exc = cb_fill_link(req.link, link);
+            if (!NIL_P(exc)) {
+                break;
+            }
+
+            auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_link_replace_response>>();
+            auto f = barrier->get_future();
+            backend->cluster->execute_http(
+              req, [barrier](couchbase::operations::analytics_link_replace_response&& resp) mutable { barrier->set_value(resp); });
+            auto resp = cb_wait_for_future(f);
+
+            if (resp.ctx.ec) {
+                if (resp.errors.empty()) {
+                    exc = cb_map_error_code(
+                      resp.ctx, fmt::format("unable to replace s3_external link `{}` on `{}`", req.link.link_name, req.link.dataverse));
+                } else {
+                    const auto& first_error = resp.errors.front();
+                    exc = cb_map_error_code(resp.ctx,
+                                            fmt::format("unable to replace s3_external link `{}` on `{}` ({}: {})",
+                                                        req.link.link_name,
+                                                        req.link.dataverse,
+                                                        first_error.code,
+                                                        first_error.message));
+                }
+                break;
+            }
+        }
+
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_analytics_link_drop(VALUE self, VALUE link, VALUE dataverse, VALUE options)
+{
+    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");
+        return Qnil;
+    }
+
+    Check_Type(link, T_STRING);
+    Check_Type(dataverse, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::analytics_link_drop_request req{};
+        exc = cb_extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+
+        req.link_name.assign(RSTRING_PTR(link), static_cast<size_t>(RSTRING_LEN(link)));
+        req.dataverse_name.assign(RSTRING_PTR(dataverse), static_cast<size_t>(RSTRING_LEN(dataverse)));
+
+        auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_link_drop_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::analytics_link_drop_response&& resp) mutable { barrier->set_value(resp); });
+        auto resp = cb_wait_for_future(f);
+
+        if (resp.ctx.ec) {
+            if (resp.errors.empty()) {
+                exc = cb_map_error_code(resp.ctx, fmt::format("unable to drop link `{}` on `{}`", req.link_name, req.dataverse_name));
+            } else {
+                const auto& first_error = resp.errors.front();
+                exc = cb_map_error_code(
+                  resp.ctx,
+                  fmt::format(
+                    "unable to drop link `{}` on `{}` ({}: {})", req.link_name, req.dataverse_name, first_error.code, first_error.message));
+            }
+            break;
+        }
+
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_analytics_link_get_all(VALUE self, VALUE options)
+{
+    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");
+        return Qnil;
+    }
+
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::analytics_link_get_all_request req{};
+        exc = cb_extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+
+        exc = cb_extract_option_string(req.link_type, options, "link_type");
+        if (!NIL_P(exc)) {
+            return exc;
+        }
+        exc = cb_extract_option_string(req.dataverse_name, options, "dataverse");
+        if (!NIL_P(exc)) {
+            return exc;
+        }
+        exc = cb_extract_option_string(req.link_name, options, "link_name");
+        if (!NIL_P(exc)) {
+            return exc;
+        }
+
+        auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_link_get_all_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::analytics_link_get_all_response&& resp) mutable { barrier->set_value(resp); });
+        auto resp = cb_wait_for_future(f);
+
+        if (resp.ctx.ec) {
+            if (resp.errors.empty()) {
+                exc = cb_map_error_code(
+                  resp.ctx,
+                  fmt::format(
+                    R"(unable to retrieve links type={}, dataverse="{}",  name="{}")", req.link_type, req.link_name, req.dataverse_name));
+            } else {
+                const auto& first_error = resp.errors.front();
+                exc = cb_map_error_code(resp.ctx,
+                                        fmt::format(R"(unable to retrieve links type={}, dataverse="{}",  name="{}" ({}: {}))",
+                                                    req.link_type,
+                                                    req.link_name,
+                                                    req.dataverse_name,
+                                                    first_error.code,
+                                                    first_error.message));
+            }
+            break;
+        }
+
+        VALUE res = rb_ary_new_capa(static_cast<long>(resp.couchbase.size() + resp.s3.size() + resp.azure_blob.size()));
+        for (const auto& link : resp.couchbase) {
+            VALUE row = rb_hash_new();
+            rb_hash_aset(row, rb_id2sym(rb_intern("type")), rb_id2sym(rb_intern("couchbase")));
+            rb_hash_aset(row, rb_id2sym(rb_intern("dataverse")), cb_str_new(link.dataverse));
+            rb_hash_aset(row, rb_id2sym(rb_intern("link_name")), cb_str_new(link.link_name));
+            rb_hash_aset(row, rb_id2sym(rb_intern("hostname")), cb_str_new(link.hostname));
+            switch (link.encryption.level) {
+                case couchbase::operations::analytics_link::encryption_level::none:
+                    rb_hash_aset(row, rb_id2sym(rb_intern("encryption_level")), rb_id2sym(rb_intern("none")));
+                    break;
+                case couchbase::operations::analytics_link::encryption_level::half:
+                    rb_hash_aset(row, rb_id2sym(rb_intern("encryption_level")), rb_id2sym(rb_intern("half")));
+                    break;
+                case couchbase::operations::analytics_link::encryption_level::full:
+                    rb_hash_aset(row, rb_id2sym(rb_intern("encryption_level")), rb_id2sym(rb_intern("full")));
+                    break;
+            }
+            rb_hash_aset(row, rb_id2sym(rb_intern("username")), cb_str_new(link.username));
+            rb_hash_aset(row, rb_id2sym(rb_intern("certificate")), cb_str_new(link.encryption.certificate));
+            rb_hash_aset(row, rb_id2sym(rb_intern("client_certificate")), cb_str_new(link.encryption.client_certificate));
+            rb_ary_push(res, row);
+        }
+        for (const auto& link : resp.s3) {
+            VALUE row = rb_hash_new();
+            rb_hash_aset(row, rb_id2sym(rb_intern("type")), rb_id2sym(rb_intern("s3")));
+            rb_hash_aset(row, rb_id2sym(rb_intern("dataverse")), cb_str_new(link.dataverse));
+            rb_hash_aset(row, rb_id2sym(rb_intern("link_name")), cb_str_new(link.link_name));
+            rb_hash_aset(row, rb_id2sym(rb_intern("access_key_id")), cb_str_new(link.access_key_id));
+            rb_hash_aset(row, rb_id2sym(rb_intern("region")), cb_str_new(link.region));
+            rb_hash_aset(row, rb_id2sym(rb_intern("service_endpoint")), cb_str_new(link.service_endpoint));
+            rb_ary_push(res, row);
+        }
+        for (const auto& link : resp.azure_blob) {
+            VALUE row = rb_hash_new();
+            rb_hash_aset(row, rb_id2sym(rb_intern("type")), rb_id2sym(rb_intern("azureblob")));
+            rb_hash_aset(row, rb_id2sym(rb_intern("dataverse")), cb_str_new(link.dataverse));
+            rb_hash_aset(row, rb_id2sym(rb_intern("link_name")), cb_str_new(link.link_name));
+            rb_hash_aset(row, rb_id2sym(rb_intern("account_name")), cb_str_new(link.account_name));
+            rb_hash_aset(row, rb_id2sym(rb_intern("blob_endpoint")), cb_str_new(link.blob_endpoint));
+            rb_hash_aset(row, rb_id2sym(rb_intern("endpoint_suffix")), cb_str_new(link.endpoint_suffix));
+            rb_ary_push(res, row);
+        }
+
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+static int
+cb_for_each_named_param_analytics(VALUE key, VALUE value, VALUE arg)
+{
+    auto* preq = reinterpret_cast<couchbase::operations::analytics_request*>(arg);
+    Check_Type(key, T_STRING);
+    Check_Type(value, T_STRING);
+    preq->named_parameters.emplace(
+      std::string_view(RSTRING_PTR(key), static_cast<std::size_t>(RSTRING_LEN(key))),
+      tao::json::from_string(std::string_view(RSTRING_PTR(value), static_cast<std::size_t>(RSTRING_LEN(value)))));
+    return ST_CONTINUE;
+}
+
+static VALUE
+cb_Backend_document_analytics(VALUE self, VALUE statement, VALUE options)
+{
+    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");
+        return Qnil;
+    }
+
+    Check_Type(statement, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::analytics_request req;
+        req.statement.assign(RSTRING_PTR(statement), static_cast<size_t>(RSTRING_LEN(statement)));
+        VALUE client_context_id = rb_hash_aref(options, rb_id2sym(rb_intern("client_context_id")));
+        if (!NIL_P(client_context_id)) {
+            Check_Type(client_context_id, T_STRING);
+            req.client_context_id.assign(RSTRING_PTR(client_context_id), static_cast<size_t>(RSTRING_LEN(client_context_id)));
+        }
+        exc = cb_extract_timeout(req, options);
         if (!NIL_P(exc)) {
             break;
         }
@@ -6993,7 +7798,7 @@ cb_Backend_document_analytics(VALUE self, VALUE statement, VALUE options)
         VALUE res = rb_hash_new();
         VALUE rows = rb_ary_new_capa(static_cast<long>(resp.payload.rows.size()));
         rb_hash_aset(res, rb_id2sym(rb_intern("rows")), rows);
-        for (auto& row : resp.payload.rows) {
+        for (const auto& row : resp.payload.rows) {
             rb_ary_push(rows, cb_str_new(row));
         }
         VALUE meta = rb_hash_new();
@@ -7686,6 +8491,48 @@ cb_Backend_leb128_decode(VALUE self, VALUE data)
     return Qnil;
 }
 
+static VALUE
+cb_Backend_query_escape(VALUE self, VALUE data)
+{
+    (void)self;
+    Check_Type(data, T_STRING);
+    auto encoded =
+      couchbase::utils::string_codec::v2::query_escape(std::string(RSTRING_PTR(data), static_cast<std::size_t>(RSTRING_LEN(data))));
+    return cb_str_new(encoded);
+}
+
+static VALUE
+cb_Backend_path_escape(VALUE self, VALUE data)
+{
+    (void)self;
+    Check_Type(data, T_STRING);
+    auto encoded =
+      couchbase::utils::string_codec::v2::path_escape(std::string(RSTRING_PTR(data), static_cast<std::size_t>(RSTRING_LEN(data))));
+    return cb_str_new(encoded);
+}
+
+static int
+cb_for_each_form_encode_value(VALUE key, VALUE value, VALUE arg)
+{
+    auto* values = reinterpret_cast<std::map<std::string, std::string>*>(arg);
+    VALUE key_str = rb_obj_as_string(key);
+    VALUE value_str = rb_obj_as_string(value);
+    values->emplace(std::string(RSTRING_PTR(key_str), static_cast<std::size_t>(RSTRING_LEN(key_str))),
+                    std::string(RSTRING_PTR(value_str), static_cast<std::size_t>(RSTRING_LEN(value_str))));
+    return ST_CONTINUE;
+}
+
+static VALUE
+cb_Backend_form_encode(VALUE self, VALUE data)
+{
+    (void)self;
+    Check_Type(data, T_HASH);
+    std::map<std::string, std::string> values{};
+    rb_hash_foreach(data, INT_FUNC(cb_for_each_form_encode_value), reinterpret_cast<VALUE>(&values));
+    auto encoded = couchbase::utils::string_codec::v2::form_encode(values);
+    return cb_str_new(encoded);
+}
+
 static void
 init_backend(VALUE mCouchbase)
 {
@@ -7748,10 +8595,10 @@ init_backend(VALUE mCouchbase)
     rb_define_method(cBackend, "collection_drop", VALUE_FUNC(cb_Backend_collection_drop), 4);
 
     rb_define_method(cBackend, "query_index_get_all", VALUE_FUNC(cb_Backend_query_index_get_all), 2);
-    rb_define_method(cBackend, "query_index_create", VALUE_FUNC(cb_Backend_query_index_create), 5);
-    rb_define_method(cBackend, "query_index_create_primary", VALUE_FUNC(cb_Backend_query_index_create_primary), 3);
-    rb_define_method(cBackend, "query_index_drop", VALUE_FUNC(cb_Backend_query_index_drop), 4);
-    rb_define_method(cBackend, "query_index_drop_primary", VALUE_FUNC(cb_Backend_query_index_drop_primary), 3);
+    rb_define_method(cBackend, "query_index_create", VALUE_FUNC(cb_Backend_query_index_create), 4);
+    rb_define_method(cBackend, "query_index_create_primary", VALUE_FUNC(cb_Backend_query_index_create_primary), 2);
+    rb_define_method(cBackend, "query_index_drop", VALUE_FUNC(cb_Backend_query_index_drop), 3);
+    rb_define_method(cBackend, "query_index_drop_primary", VALUE_FUNC(cb_Backend_query_index_drop_primary), 2);
     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);
 
@@ -7771,16 +8618,20 @@ init_backend(VALUE mCouchbase)
     rb_define_method(cBackend, "search_index_analyze_document", VALUE_FUNC(cb_Backend_search_index_analyze_document), 3);
 
     rb_define_method(cBackend, "analytics_get_pending_mutations", VALUE_FUNC(cb_Backend_analytics_get_pending_mutations), 1);
-    rb_define_method(cBackend, "analytics_dataverse_drop", VALUE_FUNC(cb_Backend_analytics_dataverse_drop), 3);
-    rb_define_method(cBackend, "analytics_dataverse_create", VALUE_FUNC(cb_Backend_analytics_dataverse_create), 3);
-    rb_define_method(cBackend, "analytics_dataset_create", VALUE_FUNC(cb_Backend_analytics_dataset_create), 6);
-    rb_define_method(cBackend, "analytics_dataset_drop", VALUE_FUNC(cb_Backend_analytics_dataset_drop), 4);
+    rb_define_method(cBackend, "analytics_dataverse_drop", VALUE_FUNC(cb_Backend_analytics_dataverse_drop), 2);
+    rb_define_method(cBackend, "analytics_dataverse_create", VALUE_FUNC(cb_Backend_analytics_dataverse_create), 2);
+    rb_define_method(cBackend, "analytics_dataset_create", VALUE_FUNC(cb_Backend_analytics_dataset_create), 3);
+    rb_define_method(cBackend, "analytics_dataset_drop", VALUE_FUNC(cb_Backend_analytics_dataset_drop), 2);
     rb_define_method(cBackend, "analytics_dataset_get_all", VALUE_FUNC(cb_Backend_analytics_dataset_get_all), 1);
     rb_define_method(cBackend, "analytics_index_get_all", VALUE_FUNC(cb_Backend_analytics_index_get_all), 1);
-    rb_define_method(cBackend, "analytics_index_create", VALUE_FUNC(cb_Backend_analytics_index_create), 6);
-    rb_define_method(cBackend, "analytics_index_drop", VALUE_FUNC(cb_Backend_analytics_index_drop), 5);
-    rb_define_method(cBackend, "analytics_link_connect", VALUE_FUNC(cb_Backend_analytics_link_connect), 4);
-    rb_define_method(cBackend, "analytics_link_disconnect", VALUE_FUNC(cb_Backend_analytics_link_disconnect), 3);
+    rb_define_method(cBackend, "analytics_index_create", VALUE_FUNC(cb_Backend_analytics_index_create), 4);
+    rb_define_method(cBackend, "analytics_index_drop", VALUE_FUNC(cb_Backend_analytics_index_drop), 3);
+    rb_define_method(cBackend, "analytics_link_connect", VALUE_FUNC(cb_Backend_analytics_link_connect), 1);
+    rb_define_method(cBackend, "analytics_link_disconnect", VALUE_FUNC(cb_Backend_analytics_link_disconnect), 1);
+    rb_define_method(cBackend, "analytics_link_create", VALUE_FUNC(cb_Backend_analytics_link_create), 2);
+    rb_define_method(cBackend, "analytics_link_replace", VALUE_FUNC(cb_Backend_analytics_link_replace), 2);
+    rb_define_method(cBackend, "analytics_link_drop", VALUE_FUNC(cb_Backend_analytics_link_drop), 3);
+    rb_define_method(cBackend, "analytics_link_get_all", VALUE_FUNC(cb_Backend_analytics_link_get_all), 1);
 
     rb_define_method(cBackend, "view_index_get_all", VALUE_FUNC(cb_Backend_view_index_get_all), 3);
     rb_define_method(cBackend, "view_index_get", VALUE_FUNC(cb_Backend_view_index_get), 4);
@@ -7797,6 +8648,9 @@ init_backend(VALUE mCouchbase)
     rb_define_singleton_method(cBackend, "snappy_uncompress", VALUE_FUNC(cb_Backend_snappy_uncompress), 1);
     rb_define_singleton_method(cBackend, "leb128_encode", VALUE_FUNC(cb_Backend_leb128_encode), 1);
     rb_define_singleton_method(cBackend, "leb128_decode", VALUE_FUNC(cb_Backend_leb128_decode), 1);
+    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);
 }
 
 void