couchbase 3.0.1 → 3.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 823424047026c1b6b4c8c61577b4fb51fe93a7be2d14379484ba873e3ee1716c
-  data.tar.gz: b08989610223adf4ab1e3d5817dece9799be67ffb3b5e5f9b29ba7d7d4f93114
+  metadata.gz: 4674765d2d910949acdc81040062ecdcf6b5089297e33bbfc02c3c1cf705b60c
+  data.tar.gz: d24c030c9b3a6620d8b7740af911a5b8640f6d98b857719e50df7981a4be46ce
 SHA512:
-  metadata.gz: fd82e96988c8d857c63d0ba655aada5315508f88f412556d20d874f4ccc1dbe8e03a31c571d6e2ff7b8ffc6ce2c75b114febc881b3d3aaa728859f527cba8210
-  data.tar.gz: 766bb40b05dad76df83d85b8a117b4f29d9d9845607ae19ad29c28c59f19f8b8545ae96ba108f5301e1e51dd46c13cac51a8e9424c31c685bc1fed3947c4a6d4
+  metadata.gz: 97e0ea2efa94117e1e3738951c86cd1d3176a5304de3e70221916fa3245c96d5d932e10558eb254e06a3047e2adaa3cc97c8e77290876d7422a3d62ecec91fe6
+  data.tar.gz: dd31e90a9bf872e1edcc03eab14796122bb201e84a42d7bb68d8630bed55612deb01ebc363465209316d5d2030e210bf404035491f60e259d216240937216b7b

data/README.md

@@ -1,11 +1,18 @@
-# Couchbase Ruby Client [![gem](https://badge.fury.io/rb/couchbase.svg)](https://rubygems.org/gems/couchbase) [![tests](https://github.com/couchbase/couchbase-ruby-client/workflows/tests/badge.svg)](https://github.com/couchbase/couchbase-ruby-client/actions?query=workflow%3Atests)
+# Couchbase Ruby Client
+
+[![license](https://img.shields.io/github/license/couchbase/couchbase-ruby-client?color=brightgreen)](https://opensource.org/licenses/Apache-2.0)
+[![gem](https://img.shields.io/gem/v/couchbase?color=brightgreen)](https://rubygems.org/gems/couchbase)
+[![commits](https://img.shields.io/github/commits-since/couchbase/couchbase-ruby-client/latest?color=brightgreen)](https://github.com/couchbase/couchbase-ruby-client/commits/master)
+[![tests](https://img.shields.io/github/workflow/status/couchbase/couchbase-ruby-client/tests?label=tests)](https://github.com/couchbase/couchbase-ruby-client/actions?query=workflow%3Atests)
+[![linters](https://img.shields.io/github/workflow/status/couchbase/couchbase-ruby-client/linters?label=linters)](https://github.com/couchbase/couchbase-ruby-client/actions?query=workflow%3Alinters)
+[![jenkins](https://img.shields.io/jenkins/build?jobUrl=http%3A%2F%2Fsdk.jenkins.couchbase.com%2Fjob%2Fruby%2Fjob%2Fruby-nightly%2F&label=jenkins)](http://sdk.jenkins.couchbase.com/job/ruby/job/ruby-nightly/)
 
 This repository contains the third generation of the official Couchbase SDK for Ruby (aka. SDKv3)
 
 ## Support and Feedback
 
-If you find an issue, please file it in [our JIRA issue tracker](https://couchbase.com/issues/browse/RCBC).
-Also you are always welcome on [our forum](https://forums.couchbase.com/c/ruby-sdk).
+If you find an issue, please file it in [our JIRA issue tracker](https://couchbase.com/issues/browse/RCBC). Also you are
+always welcome on [our forum](https://forums.couchbase.com/c/ruby-sdk).
 
 Please attach version information to ticket/post. To obtain this information use the following command:
 
@@ -18,7 +25,7 @@ The library tested with the MRI 2.5, 2.6 and 2.7. Supported platforms are Linux
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "couchbase", "3.0.1"
+gem "couchbase", "3.0.2"
 ```
 
 And then execute:
@@ -33,6 +40,54 @@ For some platforms we precompile binary packages. When, for some reason, binary
 `--platform=ruby` to `gem install` command (or check `specific_platform` and `force_ruby_platform` options of Bundler).
 In latter case, see [Development](#development) section for build dependencies.
 
+## Usage
+
+Here is a basic steps demonstrating basic operations with data:
+
+```ruby
+require "couchbase"
+include Couchbase # include Couchbase module for brevity
+
+# initialize library
+cluster = Cluster.connect("couchbase://127.0.0.1", "Administrator", "password")
+
+# open bucket and collection for data operations
+bucket = cluster.bucket("my_bucket")
+collection = bucket.default_collection
+
+# update or insert the document
+res = collection.upsert("foo", {"bar" => 42})
+res.cas
+#=> 22120998714646
+
+# retrieve document from the collection
+res = collection.get("foo")
+res.cas
+#=> 22120998714646
+res.content
+#=> {"bar"=>42}
+
+# remove document
+res = collection.remove("foo")
+res.cas
+#=> 47891154812182
+
+# fetch top-3 cities by number of hotels in the collection
+res = cluster.query("
+          SELECT city, COUNT(*) AS cnt FROM `travel-sample`
+          WHERE type = $type
+          GROUP BY city
+          ORDER BY cnt DESC
+          LIMIT 3",
+        Options::Query(named_parameters: {type: "hotel"}, metrics: true))
+res.rows.each do |row|
+  p row
+end
+#=> {"city"=>"San Francisco", "cnt"=>132}
+#   {"city"=>"London", "cnt"=>67}
+#   {"city"=>"Paris", "cnt"=>64}
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive
@@ -60,3 +115,17 @@ Now the API reference is accessible using web browser (where `VERSION` is curren
 ## License
 
 The gem is available as open source under the terms of the [Apache2 License](https://opensource.org/licenses/Apache-2.0).
+
+    Copyright 2011-2020 Couchbase, Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.

data/ext/build_config.hxx.in

@@ -18,3 +18,5 @@
 #pragma once
 
 #cmakedefine TLS_KEY_LOG_FILE "@TLS_KEY_LOG_FILE@"
+#cmakedefine STATIC_STDLIB 1
+#cmakedefine STATIC_OPENSSL 1

data/ext/build_version.hxx.in

@@ -17,11 +17,14 @@
 
 #pragma once
 
-#define BACKEND_BUILD_TIMESTAMP "@BACKEND_BUILD_TIMESTAMP@"
-#define BACKEND_CXX_COMPILER "@CMAKE_CXX_COMPILER_ID@ @CMAKE_CXX_COMPILER_VERSION@"
-#define BACKEND_C_COMPILER "@CMAKE_C_COMPILER_ID@ @CMAKE_C_COMPILER_VERSION@"
-#define BACKEND_SYSTEM "@CMAKE_SYSTEM@"
-#define BACKEND_SYSTEM_PROCESSOR "@CMAKE_SYSTEM_PROCESSOR@"
-#define BACKEND_GIT_REVISION "b59cb40f11ec2dba992eda285eae5cd7238a59c3"
-#cmakedefine STATIC_STDLIB 1
-#cmakedefine STATIC_OPENSSL 1
+#include <build_config.hxx>
+
+namespace couchbase
+{
+constexpr auto BACKEND_BUILD_TIMESTAMP = "@BACKEND_BUILD_TIMESTAMP@";
+constexpr auto BACKEND_CXX_COMPILER = "@CMAKE_CXX_COMPILER_ID@ @CMAKE_CXX_COMPILER_VERSION@";
+constexpr auto BACKEND_C_COMPILER = "@CMAKE_C_COMPILER_ID@ @CMAKE_C_COMPILER_VERSION@";
+constexpr auto BACKEND_SYSTEM = "@CMAKE_SYSTEM@";
+constexpr auto BACKEND_SYSTEM_PROCESSOR = "@CMAKE_SYSTEM_PROCESSOR@";
+constexpr auto BACKEND_GIT_REVISION = "9d2e94b96a3537e8bfc8c9ca88a1c855db6ec977";
+} // namespace couchbase

data/ext/cmake/BuildTracing.cmake

@@ -1,6 +1,6 @@
 if(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
   option(ENABLE_BUILD_WITH_TIME_TRACE "Enable -ftime-trace to generate time tracing .json files on clang" OFF)
   if(ENABLE_BUILD_WITH_TIME_TRACE)
-    target_compile_definitions(project_options INTERFACE -ftime-trace)
+    target_compile_options(project_options INTERFACE -ftime-trace)
   endif()
 endif()

data/ext/cmake/CompilerWarnings.cmake

@@ -47,6 +47,11 @@ function(set_project_warnings project_name)
       -Wnull-dereference # warn if a null dereference is detected
       -Wdouble-promotion # warn if float is implicit promoted to double
       -Wformat=2 # warn on security issues around functions that format output (ie printf)
+
+      # TODO: make it local to ext/couchbase/couchbase.cxx
+      -Wno-unknown-warning-option
+      -Wno-gnu-statement-expression
+      -Wno-compound-token-split-by-macro
   )
 
   if(WARNINGS_AS_ERRORS)

data/ext/cmake/Testing.cmake

@@ -14,7 +14,7 @@ if(ENABLE_TESTING)
   include(Catch)
 
   macro(ruby_test name)
-    add_executable(test_ruby_${name} test/test_ruby_${name}.cxx)
+    add_executable(test_ruby_${name} "${CMAKE_SOURCE_DIR}/test/test_ruby_${name}.cxx")
     target_include_directories(test_ruby_${name} PRIVATE ${PROJECT_BINARY_DIR}/generated)
     target_link_libraries(
       test_ruby_${name}
@@ -27,7 +27,7 @@ if(ENABLE_TESTING)
   endmacro()
 
   macro(native_test name)
-    add_executable(test_native_${name} test/test_native_${name}.cxx)
+    add_executable(test_native_${name} "${CMAKE_SOURCE_DIR}/test/test_native_${name}.cxx")
     target_include_directories(test_native_${name} PRIVATE ${PROJECT_BINARY_DIR}/generated)
     target_link_libraries(
       test_native_${name}
@@ -45,8 +45,5 @@ if(ENABLE_TESTING)
     catch_discover_tests(test_native_${name})
   endmacro()
 
-  ruby_test(trivial_crud)
-  ruby_test(trivial_query)
-  native_test(trivial_crud)
-  native_test(diagnostics)
+  add_subdirectory(${CMAKE_SOURCE_DIR}/test)
 endif()

data/ext/couchbase/bucket.hxx

@@ -17,8 +17,8 @@
 
 #pragma once
 
-#include <utility>
 #include <queue>
+#include <utility>
 
 #include <operations.hxx>
 #include <origin.hxx>
@@ -317,6 +317,14 @@ class bucket : public std::enable_shared_from_this<bucket>
         }
     }
 
+    template<typename Collector>
+    void ping(std::shared_ptr<Collector> collector)
+    {
+        for (const auto& session : sessions_) {
+            session.second->ping(collector->build_reporter());
+        }
+    }
+
   private:
     std::string client_id_;
     asio::io_context& ctx_;

data/ext/couchbase/cbsasl/client.h

@@ -58,7 +58,7 @@ class MechanismBackend
     virtual ~MechanismBackend() = default;
     virtual std::pair<error, std::string_view> start() = 0;
     virtual std::pair<error, std::string_view> step(std::string_view input) = 0;
-    virtual std::string_view get_name() const = 0;
+    [[nodiscard]] virtual std::string_view get_name() const = 0;
 
   protected:
     const GetUsernameCallback usernameCallback;

data/ext/couchbase/cluster.hxx

@@ -36,6 +36,54 @@
 
 namespace couchbase
 {
+namespace
+{
+class ping_collector : public std::enable_shared_from_this<ping_collector>
+{
+    diag::ping_result res_;
+    std::function<void(diag::ping_result)> handler_;
+    std::atomic_int expected_{ 0 };
+    std::mutex mutex_{};
+
+  public:
+    ping_collector(std::string report_id, std::function<void(diag::ping_result)> handler)
+      : res_{ std::move(report_id), couchbase::sdk_id() }
+      , handler_(std::move(handler))
+    {
+    }
+
+    ~ping_collector()
+    {
+        invoke_handler();
+    }
+
+    [[nodiscard]] diag::ping_result& result()
+    {
+        return res_;
+    }
+
+    auto build_reporter()
+    {
+        expected_++;
+        return [self = this->shared_from_this()](diag::endpoint_ping_info&& info) {
+            std::scoped_lock lock(self->mutex_);
+            self->res_.services[info.type].emplace_back(info);
+            if (--self->expected_ == 0) {
+                self->invoke_handler();
+            }
+        };
+    }
+
+    void invoke_handler()
+    {
+        if (handler_ != nullptr) {
+            handler_(std::move(res_));
+            handler_ = nullptr;
+        }
+    }
+};
+} // namespace
+
 class cluster
 {
   public:
@@ -129,10 +177,7 @@ class cluster
             report_id = std::make_optional(uuid::to_string(uuid::random()));
         }
         asio::post(asio::bind_executor(ctx_, [this, report_id, handler = std::forward<Handler>(handler)]() mutable {
-            diag::diagnostics_result res{
-                report_id.value(),
-                fmt::format("ruby/{}.{}.{}/{}", BACKEND_VERSION_MAJOR, BACKEND_VERSION_MINOR, BACKEND_VERSION_PATCH, BACKEND_GIT_REVISION)
-            };
+            diag::diagnostics_result res{ report_id.value(), couchbase::sdk_id() };
             if (session_) {
                 res.services[service_type::kv].emplace_back(session_->diag_info());
             }
@@ -144,6 +189,40 @@ class cluster
         }));
     }
 
+    void ping(std::optional<std::string> report_id,
+              std::optional<std::string> bucket_name,
+              std::set<service_type> services,
+              std::function<void(diag::ping_result)> handler)
+    {
+        if (!report_id) {
+            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 };
+        }
+        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()) {
+                    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 (session_) {
+                        session_->ping(collector->build_reporter());
+                    }
+                    for (auto& bucket : buckets_) {
+                        bucket.second->ping(collector);
+                    }
+                }
+                session_manager_->ping(services, collector, origin_.credentials());
+            }
+        }));
+    }
+
   private:
     template<typename Handler>
     void do_dns_srv(Handler&& handler)
@@ -155,7 +234,7 @@ class cluster
         dns_client_.query_srv(
           hostname,
           service,
-          [hostname, this, handler = std::forward<Handler>(handler)](couchbase::io::dns::dns_client::dns_srv_response resp) mutable {
+          [hostname, this, handler = std::forward<Handler>(handler)](couchbase::io::dns::dns_client::dns_srv_response&& resp) mutable {
               if (resp.ec) {
                   spdlog::warn("failed to fetch DNS SRV records for \"{}\" ({}), assuming that cluster is listening this address",
                                hostname,
@@ -227,7 +306,11 @@ class cluster
             if (!ec) {
                 if (origin_.options().network == "auto") {
                     origin_.options().network = config.select_network(session_->bootstrap_hostname());
-                    spdlog::info(R"({} detected network is "{}")", session_->log_prefix(), origin_.options().network);
+                    if (origin_.options().network == "default") {
+                        spdlog::debug(R"({} detected network is "{}")", session_->log_prefix(), origin_.options().network);
+                    } else {
+                        spdlog::info(R"({} detected network is "{}")", session_->log_prefix(), origin_.options().network);
+                    }
                 }
                 if (origin_.options().network != "default") {
                     origin::node_list nodes;

data/ext/couchbase/configuration.hxx

@@ -17,6 +17,8 @@
 
 #pragma once
 
+#include <set>
+
 #include <gsl/gsl_util>
 
 #include <tao/json.hpp>

data/ext/couchbase/couchbase.cxx

@@ -15,8 +15,8 @@
  *   limitations under the License.
  */
 
-#include <build_config.hxx>
 #include <build_info.hxx>
+#include <version.hxx>
 
 #include <openssl/crypto.h>
 #include <asio/version.hpp>
@@ -28,7 +28,6 @@
 
 #include <snappy.h>
 
-#include <version.hxx>
 #include <platform/terminate_handler.h>
 
 #include <cluster.hxx>
@@ -63,14 +62,14 @@ init_versions(VALUE mCouchbase)
 #define VERSION_SPLIT_(VER) (VER) / 100000, (VER) / 100 % 1000, (VER) % 100
 
     std::string ver;
-    ver = fmt::format("{}.{}.{}", BACKEND_VERSION_MAJOR, BACKEND_VERSION_MINOR, BACKEND_VERSION_PATCH);
+    ver = fmt::format("{}.{}.{}", couchbase::BACKEND_VERSION_MAJOR, couchbase::BACKEND_VERSION_MINOR, couchbase::BACKEND_VERSION_PATCH);
     rb_hash_aset(cb_Version, rb_id2sym(rb_intern("backend")), rb_str_freeze(rb_str_new(ver.c_str(), static_cast<long>(ver.size()))));
-    rb_hash_aset(cb_Version, rb_id2sym(rb_intern("build_timestamp")), rb_str_freeze(rb_str_new_cstr(BACKEND_BUILD_TIMESTAMP)));
-    rb_hash_aset(cb_Version, rb_id2sym(rb_intern("revision")), rb_str_freeze(rb_str_new_cstr(BACKEND_GIT_REVISION)));
-    rb_hash_aset(cb_Version, rb_id2sym(rb_intern("platform")), rb_str_freeze(rb_str_new_cstr(BACKEND_SYSTEM)));
-    rb_hash_aset(cb_Version, rb_id2sym(rb_intern("cpu")), rb_str_freeze(rb_str_new_cstr(BACKEND_SYSTEM_PROCESSOR)));
-    rb_hash_aset(cb_Version, rb_id2sym(rb_intern("cc")), rb_str_freeze(rb_str_new_cstr(BACKEND_C_COMPILER)));
-    rb_hash_aset(cb_Version, rb_id2sym(rb_intern("cxx")), rb_str_freeze(rb_str_new_cstr(BACKEND_CXX_COMPILER)));
+    rb_hash_aset(cb_Version, rb_id2sym(rb_intern("build_timestamp")), rb_str_freeze(rb_str_new_cstr(couchbase::BACKEND_BUILD_TIMESTAMP)));
+    rb_hash_aset(cb_Version, rb_id2sym(rb_intern("revision")), rb_str_freeze(rb_str_new_cstr(couchbase::BACKEND_GIT_REVISION)));
+    rb_hash_aset(cb_Version, rb_id2sym(rb_intern("platform")), rb_str_freeze(rb_str_new_cstr(couchbase::BACKEND_SYSTEM)));
+    rb_hash_aset(cb_Version, rb_id2sym(rb_intern("cpu")), rb_str_freeze(rb_str_new_cstr(couchbase::BACKEND_SYSTEM_PROCESSOR)));
+    rb_hash_aset(cb_Version, rb_id2sym(rb_intern("cc")), rb_str_freeze(rb_str_new_cstr(couchbase::BACKEND_C_COMPILER)));
+    rb_hash_aset(cb_Version, rb_id2sym(rb_intern("cxx")), rb_str_freeze(rb_str_new_cstr(couchbase::BACKEND_CXX_COMPILER)));
 #if defined(HAVE_RUBY_VERSION_H)
     ver = fmt::format("{}.{}.{}", RUBY_API_VERSION_MAJOR, RUBY_API_VERSION_MINOR, RUBY_API_VERSION_TEENY);
     rb_hash_aset(cb_Version, rb_id2sym(rb_intern("ruby")), rb_str_freeze(rb_str_new(ver.c_str(), static_cast<long>(ver.size()))));
@@ -593,6 +592,7 @@ cb_Backend_open(VALUE self, VALUE connection_string, VALUE credentials, VALUE op
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
     Check_Type(connection_string, T_STRING);
     Check_Type(credentials, T_HASH);
@@ -619,6 +619,11 @@ cb_Backend_open(VALUE self, VALUE connection_string, VALUE credentials, VALUE op
     do {
         std::string input(RSTRING_PTR(connection_string), static_cast<size_t>(RSTRING_LEN(connection_string)));
         auto connstr = couchbase::utils::parse_connection_string(input);
+        if (connstr.error) {
+            exc = rb_exc_new_cstr(eInvalidArgument,
+                                  fmt::format(R"(Failed to parse connection string "{}": {})", input, connstr.error.value()).c_str());
+            break;
+        }
         couchbase::cluster_credentials auth{};
         if (NIL_P(certificate_path) || NIL_P(key_path)) {
             auth.username.assign(RSTRING_PTR(username), static_cast<size_t>(RSTRING_LEN(username)));
@@ -664,6 +669,7 @@ cb_Backend_diagnostics(VALUE self, VALUE report_id)
     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(report_id)) {
@@ -678,7 +684,7 @@ cb_Backend_diagnostics(VALUE self, VALUE report_id)
         }
         auto barrier = std::make_shared<std::promise<couchbase::diag::diagnostics_result>>();
         auto f = barrier->get_future();
-        backend->cluster->diagnostics(id, [barrier](couchbase::diag::diagnostics_result resp) mutable { barrier->set_value(resp); });
+        backend->cluster->diagnostics(id, [barrier](couchbase::diag::diagnostics_result&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
 
         VALUE res = rb_hash_new();
@@ -734,6 +740,10 @@ cb_Backend_diagnostics(VALUE self, VALUE report_id)
                         state = rb_id2sym(rb_intern("disconnecting"));
                         break;
                 }
+                if (svc.details) {
+                    rb_hash_aset(
+                      service, rb_id2sym(rb_intern("details")), rb_str_new(svc.details->data(), static_cast<long>(svc.details->size())));
+                }
                 rb_hash_aset(service, rb_id2sym(rb_intern("state")), state);
                 rb_ary_push(endpoints, service);
             }
@@ -752,6 +762,7 @@ cb_Backend_open_bucket(VALUE self, VALUE bucket, VALUE wait_until_ready)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket, T_STRING);
@@ -780,29 +791,467 @@ cb_Backend_open_bucket(VALUE self, VALUE bucket, VALUE wait_until_ready)
 }
 
 template<typename Request>
-void
-cb__extract_timeout(Request& req, VALUE timeout)
+[[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(timeout)) {
-        switch (TYPE(timeout)) {
+    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:
-                req.timeout = std::chrono::milliseconds(NUM2ULL(timeout));
+                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:
-                rb_raise(rb_eArgError, "timeout must be an Integer");
+                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)
+{
+    if (TYPE(arg) != T_ARRAY) {
+        return rb_exc_new_str(rb_eArgError, rb_sprintf("Type of IDs argument must be an Array, but given %+" PRIsVALUE, arg));
+    }
+    auto num_of_ids = static_cast<std::size_t>(RARRAY_LEN(arg));
+    if (num_of_ids < 1) {
+        rb_raise(rb_eArgError, "Array of IDs must not be empty");
+    }
+    ids.reserve(num_of_ids);
+    for (std::size_t i = 0; i < num_of_ids; ++i) {
+        VALUE entry = rb_ary_entry(arg, static_cast<long>(i));
+        if (TYPE(entry) != T_ARRAY || RARRAY_LEN(entry) != 3) {
+            return rb_exc_new_str(
+              rb_eArgError, rb_sprintf("ID tuple must be represented as an Array[bucket, collection, id], but given %+" PRIsVALUE, entry));
+        }
+        VALUE bucket = rb_ary_entry(entry, 0);
+        if (TYPE(bucket) != T_STRING) {
+            return rb_exc_new_str(rb_eArgError, rb_sprintf("Bucket must be a String, but given %+" PRIsVALUE, bucket));
+        }
+        VALUE collection = rb_ary_entry(entry, 1);
+        if (TYPE(collection) != T_STRING) {
+            return rb_exc_new_str(rb_eArgError, rb_sprintf("Collection must be a String, but given %+" PRIsVALUE, collection));
+        }
+        VALUE id = rb_ary_entry(entry, 2);
+        if (TYPE(id) != T_STRING) {
+            return rb_exc_new_str(rb_eArgError, rb_sprintf("ID must be a String, but given %+" PRIsVALUE, id));
+        }
+        ids.emplace_back(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))),
+        });
+    }
+
+    return Qnil;
+}
+
+[[nodiscard]] VALUE
+cb__extract_array_of_id_content(std::vector<std::tuple<couchbase::document_id, std::string, std::uint32_t>>& id_content, VALUE arg)
+{
+    if (TYPE(arg) != T_ARRAY) {
+        return rb_exc_new_str(rb_eArgError, rb_sprintf("Type of ID/content tuples must be an Array, but given %+" PRIsVALUE, arg));
+    }
+    auto num_of_tuples = static_cast<std::size_t>(RARRAY_LEN(arg));
+    if (num_of_tuples < 1) {
+        rb_raise(rb_eArgError, "Array of ID/content tuples must not be empty");
+    }
+    id_content.reserve(num_of_tuples);
+    for (std::size_t i = 0; i < num_of_tuples; ++i) {
+        VALUE entry = rb_ary_entry(arg, static_cast<long>(i));
+        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,
+                         entry));
+        }
+        VALUE bucket = rb_ary_entry(entry, 0);
+        if (TYPE(bucket) != T_STRING) {
+            return rb_exc_new_str(rb_eArgError, rb_sprintf("Bucket must be a String, but given %+" PRIsVALUE, bucket));
+        }
+        VALUE collection = rb_ary_entry(entry, 1);
+        if (TYPE(collection) != T_STRING) {
+            return rb_exc_new_str(rb_eArgError, rb_sprintf("Collection must be a String, but given %+" PRIsVALUE, collection));
+        }
+        VALUE id = rb_ary_entry(entry, 2);
+        if (TYPE(id) != T_STRING) {
+            return rb_exc_new_str(rb_eArgError, rb_sprintf("ID must be a String, but given %+" PRIsVALUE, id));
+        }
+        VALUE content = rb_ary_entry(entry, 3);
+        if (TYPE(content) != T_STRING) {
+            return rb_exc_new_str(rb_eArgError, rb_sprintf("Content must be a String, but given %+" PRIsVALUE, content));
+        }
+        VALUE flags = rb_ary_entry(entry, 4);
+        if (TYPE(flags) != T_FIXNUM) {
+            return rb_exc_new_str(rb_eArgError, rb_sprintf("Flags must be an Integer, but given %+" PRIsVALUE, flags));
+        }
+        id_content.emplace_back(std::make_tuple(
+          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))),
+          },
+          std::string(RSTRING_PTR(content), static_cast<size_t>(RSTRING_LEN(content))),
+          FIX2UINT(flags)));
+    }
+
+    return Qnil;
+}
+
+[[nodiscard]] VALUE
+cb__extract_array_of_id_cas(std::vector<std::pair<couchbase::document_id, std::uint64_t>>& id_cas, VALUE arg)
+{
+    if (TYPE(arg) != T_ARRAY) {
+        return rb_exc_new_str(rb_eArgError, rb_sprintf("Type of ID/CAS tuples must be an Array, but given %+" PRIsVALUE, arg));
+    }
+    auto num_of_tuples = static_cast<std::size_t>(RARRAY_LEN(arg));
+    if (num_of_tuples < 1) {
+        rb_raise(rb_eArgError, "Array of ID/CAS tuples must not be empty");
+    }
+    id_cas.reserve(num_of_tuples);
+    for (std::size_t i = 0; i < num_of_tuples; ++i) {
+        VALUE entry = rb_ary_entry(arg, static_cast<long>(i));
+        if (TYPE(entry) != T_ARRAY || RARRAY_LEN(entry) != 4) {
+            return rb_exc_new_str(
+              rb_eArgError,
+              rb_sprintf("ID/content tuple must be represented as an Array[bucket, collection, id, CAS], but given %+" PRIsVALUE, entry));
+        }
+        VALUE bucket = rb_ary_entry(entry, 0);
+        if (TYPE(bucket) != T_STRING) {
+            return rb_exc_new_str(rb_eArgError, rb_sprintf("Bucket must be a String, but given %+" PRIsVALUE, bucket));
+        }
+        VALUE collection = rb_ary_entry(entry, 1);
+        if (TYPE(collection) != T_STRING) {
+            return rb_exc_new_str(rb_eArgError, rb_sprintf("Collection must be a String, but given %+" PRIsVALUE, collection));
+        }
+        VALUE id = rb_ary_entry(entry, 2);
+        if (TYPE(id) != T_STRING) {
+            return rb_exc_new_str(rb_eArgError, rb_sprintf("ID must be a String, but given %+" PRIsVALUE, id));
+        }
+        std::uint64_t cas_val = 0;
+        VALUE cas = rb_ary_entry(entry, 3);
+        if (!NIL_P(cas)) {
+            switch (TYPE(cas)) {
+                case T_FIXNUM:
+                case T_BIGNUM:
+                    cas_val = NUM2ULL(cas);
+                    break;
+                default:
+                    return rb_exc_new_str(rb_eArgError, rb_sprintf("CAS must be an Integer or nil, but given %+" PRIsVALUE, cas));
+            }
+        }
+
+        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));
+    }
+
+    return Qnil;
+}
+
+[[nodiscard]] VALUE
+cb__extract_option_symbol(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_SYMBOL) {
+            return Qnil;
+        }
+        return rb_exc_new_str(rb_eArgError, rb_sprintf("%s must be an Symbol, but given %+" PRIsVALUE, name, val));
+    }
+    return Qnil;
+}
+
+[[nodiscard]] VALUE
+cb__extract_option_string(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_STRING) {
+            return Qnil;
+        }
+        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;
+}
+
+[[nodiscard]] VALUE
+cb__extract_durability(couchbase::protocol::durability_level& output_level, std::optional<std::uint16_t>& output_timeout, VALUE options)
+{
+    VALUE durability_level = Qnil;
+    VALUE exc = cb__extract_option_symbol(durability_level, options, "durability_level");
+    if (!NIL_P(exc)) {
+        return exc;
+    }
+    if (!NIL_P(durability_level)) {
+        ID level = rb_sym2id(durability_level);
+        if (level == rb_intern("none")) {
+            output_level = couchbase::protocol::durability_level::none;
+        } else if (level == rb_intern("majority")) {
+            output_level = couchbase::protocol::durability_level::majority;
+        } else if (level == rb_intern("majority_and_persist_to_active")) {
+            output_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
+        } else if (level == rb_intern("persist_to_majority")) {
+            output_level = couchbase::protocol::durability_level::persist_to_majority;
+        } else {
+            return rb_exc_new_str(eInvalidArgument, rb_sprintf("unknown durability level: %+" PRIsVALUE, durability_level));
+        }
+        VALUE durability_timeout = Qnil;
+        exc = cb__extract_option_fixnum(durability_timeout, options, "durability_timeout");
+        if (!NIL_P(exc)) {
+            return exc;
         }
+        if (!NIL_P(durability_timeout)) {
+            output_timeout = FIX2UINT(durability_timeout);
+        }
+    }
+    return Qnil;
+}
+
+template<typename Request>
+[[nodiscard]] VALUE
+cb__extract_durability(Request& req, VALUE options)
+{
+    return cb__extract_durability(req.durability_level, req.durability_timeout, options);
+}
+
+static VALUE
+cb_Backend_ping(VALUE self, VALUE bucket, 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(bucket)) {
+        Check_Type(bucket, T_STRING);
+    }
+
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
     }
+
+    VALUE exc = Qnil;
+    do {
+        VALUE id = Qnil;
+        exc = cb__extract_option_string(id, options, "report_id");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        std::optional<std::string> report_id{};
+        if (!NIL_P(id)) {
+            report_id.emplace(std::string(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id))));
+        }
+        std::optional<std::string> bucket_name{};
+        if (!NIL_P(bucket)) {
+            bucket_name.emplace(std::string(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket))));
+        }
+        VALUE services = Qnil;
+        exc = cb__extract_option_array(services, options, "service_types");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        std::set<couchbase::service_type> selected_services{};
+        if (!NIL_P(services)) {
+            auto entries_num = static_cast<size_t>(RARRAY_LEN(services));
+            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);
+                } else if (entry == rb_id2sym(rb_intern("query"))) {
+                    selected_services.insert(couchbase::service_type::query);
+                } else if (entry == rb_id2sym(rb_intern("analytics"))) {
+                    selected_services.insert(couchbase::service_type::analytics);
+                } 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);
+                }
+            }
+        }
+        auto barrier = std::make_shared<std::promise<couchbase::diag::ping_result>>();
+        auto f = barrier->get_future();
+        backend->cluster->ping(
+          report_id, bucket_name, selected_services, [barrier](couchbase::diag::ping_result&& resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("id")), rb_str_new(resp.id.data(), static_cast<long>(resp.id.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("sdk")), rb_str_new(resp.sdk.data(), static_cast<long>(resp.sdk.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("version")), INT2FIX(resp.version));
+        services = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("services")), services);
+        for (const auto& svcs : resp.services) {
+            VALUE type = Qnil;
+            switch (svcs.first) {
+                case couchbase::service_type::kv:
+                    type = rb_id2sym(rb_intern("kv"));
+                    break;
+                case couchbase::service_type::query:
+                    type = rb_id2sym(rb_intern("query"));
+                    break;
+                case couchbase::service_type::analytics:
+                    type = rb_id2sym(rb_intern("analytics"));
+                    break;
+                case couchbase::service_type::search:
+                    type = rb_id2sym(rb_intern("search"));
+                    break;
+                case couchbase::service_type::views:
+                    type = rb_id2sym(rb_intern("views"));
+                    break;
+                case couchbase::service_type::management:
+                    type = rb_id2sym(rb_intern("mgmt"));
+                    break;
+            }
+            VALUE endpoints = rb_ary_new();
+            rb_hash_aset(services, type, endpoints);
+            for (const auto& svc : svcs.second) {
+                VALUE service = rb_hash_new();
+                rb_hash_aset(service, rb_id2sym(rb_intern("latency")), LL2NUM(svc.latency.count()));
+                rb_hash_aset(service, rb_id2sym(rb_intern("id")), rb_str_new(svc.id.data(), static_cast<long>(svc.id.size())));
+                rb_hash_aset(service, rb_id2sym(rb_intern("remote")), rb_str_new(svc.remote.data(), static_cast<long>(svc.remote.size())));
+                rb_hash_aset(service, rb_id2sym(rb_intern("local")), rb_str_new(svc.local.data(), static_cast<long>(svc.local.size())));
+                VALUE state = Qnil;
+                switch (svc.state) {
+                    case couchbase::diag::ping_state::ok:
+                        state = rb_id2sym(rb_intern("ok"));
+                        break;
+                    case couchbase::diag::ping_state::timeout:
+                        state = rb_id2sym(rb_intern("timeout"));
+                        break;
+                    case couchbase::diag::ping_state::error:
+                        state = rb_id2sym(rb_intern("error"));
+                        if (svc.error) {
+                            rb_hash_aset(
+                              service, rb_id2sym(rb_intern("error")), rb_str_new(svc.error->data(), static_cast<long>(svc.error->size())));
+                        }
+                        break;
+                }
+                rb_hash_aset(service, rb_id2sym(rb_intern("state")), state);
+                rb_ary_push(endpoints, service);
+            }
+        }
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
 }
 
 static VALUE
-cb_Backend_document_get(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout)
+cb_Backend_document_get(VALUE self, VALUE bucket, VALUE collection, VALUE id, 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(bucket, T_STRING);
@@ -817,13 +1266,16 @@ cb_Backend_document_get(VALUE self, VALUE bucket, VALUE collection, VALUE id, VA
         doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
 
         couchbase::operations::get_request req{ doc_id };
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
         auto barrier = std::make_shared<std::promise<couchbase::operations::get_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute(req, [barrier](couchbase::operations::get_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute(req, [barrier](couchbase::operations::get_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable fetch {} (opaque={})", doc_id, resp.opaque));
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable fetch "{}" (opaque={}))", doc_id, resp.opaque));
             break;
         }
 
@@ -838,26 +1290,82 @@ cb_Backend_document_get(VALUE self, VALUE bucket, VALUE collection, VALUE id, VA
 }
 
 static VALUE
-cb_Backend_document_get_projected(VALUE self,
-                                  VALUE bucket,
-                                  VALUE collection,
-                                  VALUE id,
-                                  VALUE timeout,
-                                  VALUE with_expiry,
-                                  VALUE projections,
-                                  VALUE preserve_array_indexes)
+cb_Backend_document_get_multi(VALUE self, VALUE keys, 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;
+    }
+
+    VALUE exc = Qnil;
+    do {
+        std::chrono::milliseconds timeout{ 0 };
+        exc = cb__extract_timeout(timeout, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+
+        std::vector<couchbase::document_id> ids{};
+        exc = cb__extract_array_of_ids(ids, keys);
+        if (!NIL_P(exc)) {
+            break;
+        }
+
+        auto num_of_ids = ids.size();
+        std::vector<std::shared_ptr<std::promise<couchbase::operations::get_response>>> barriers;
+        barriers.reserve(num_of_ids);
+
+        for (auto& id : ids) {
+            couchbase::operations::get_request req{ std::move(id) };
+            if (timeout.count() > 0) {
+                req.timeout = timeout;
+            }
+            auto barrier = std::make_shared<std::promise<couchbase::operations::get_response>>();
+            backend->cluster->execute(req, [barrier](couchbase::operations::get_response&& resp) mutable { barrier->set_value(resp); });
+            barriers.emplace_back(barrier);
+        }
+
+        VALUE res = rb_ary_new_capa(static_cast<long>(num_of_ids));
+        for (auto& barrier : barriers) {
+            auto resp = barrier->get_future().get();
+            VALUE entry = rb_hash_new();
+            if (resp.ec) {
+                rb_hash_aset(entry,
+                             rb_id2sym(rb_intern("error")),
+                             cb__map_error_code(resp.ec, fmt::format(R"(unable fetch "{}" (opaque={}))", resp.id, resp.opaque)));
+            }
+            rb_hash_aset(entry, rb_id2sym(rb_intern("content")), rb_str_new(resp.value.data(), static_cast<long>(resp.value.size())));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
+            rb_hash_aset(entry, rb_id2sym(rb_intern("flags")), UINT2NUM(resp.flags));
+            rb_ary_push(res, entry);
+        }
+
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_document_get_projected(VALUE self, VALUE bucket, VALUE collection, VALUE id, 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(bucket, T_STRING);
     Check_Type(collection, T_STRING);
     Check_Type(id, T_STRING);
-
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
     VALUE exc = Qnil;
     do {
         couchbase::document_id doc_id;
@@ -866,12 +1374,29 @@ cb_Backend_document_get_projected(VALUE self,
         doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
 
         couchbase::operations::get_projected_request req{ doc_id };
-        cb__extract_timeout(req, timeout);
-        req.with_expiry = RTEST(with_expiry);
-        req.preserve_array_indexes = RTEST(preserve_array_indexes);
+        exc = cb__extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+        exc = cb__extract_option_bool(req.with_expiry, options, "with_expiry");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        exc = cb__extract_option_bool(req.preserve_array_indexes, options, "preserve_array_indexes");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        VALUE projections = Qnil;
+        exc = cb__extract_option_array(projections, options, "projections");
+        if (!NIL_P(exc)) {
+            break;
+        }
         if (!NIL_P(projections)) {
-            Check_Type(projections, T_ARRAY);
             auto entries_num = static_cast<size_t>(RARRAY_LEN(projections));
+            if (entries_num == 0) {
+                exc = rb_exc_new_cstr(rb_eArgError, "projections array must not be empty");
+                break;
+            }
             req.projections.reserve(entries_num);
             for (size_t i = 0; i < entries_num; ++i) {
                 VALUE entry = rb_ary_entry(projections, static_cast<long>(i));
@@ -882,10 +1407,11 @@ cb_Backend_document_get_projected(VALUE self,
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::get_projected_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute(req, [barrier](couchbase::operations::get_projected_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute(req,
+                                  [barrier](couchbase::operations::get_projected_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable fetch with projections {} (opaque={})", doc_id, resp.opaque));
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable fetch with projections "{}" (opaque={}))", doc_id, resp.opaque));
             break;
         }
 
@@ -903,19 +1429,23 @@ cb_Backend_document_get_projected(VALUE self,
 }
 
 static VALUE
-cb_Backend_document_get_and_lock(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE lock_time)
+cb_Backend_document_get_and_lock(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE lock_time, 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(bucket, T_STRING);
     Check_Type(collection, T_STRING);
     Check_Type(id, T_STRING);
     Check_Type(lock_time, T_FIXNUM);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
@@ -925,15 +1455,19 @@ cb_Backend_document_get_and_lock(VALUE self, VALUE bucket, VALUE collection, VAL
         doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
 
         couchbase::operations::get_and_lock_request req{ doc_id };
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.lock_time = NUM2UINT(lock_time);
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::get_and_lock_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute(req, [barrier](couchbase::operations::get_and_lock_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute(req,
+                                  [barrier](couchbase::operations::get_and_lock_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable lock and fetch {} (opaque={})", doc_id, resp.opaque));
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable lock and fetch "{}" (opaque={}))", doc_id, resp.opaque));
             break;
         }
 
@@ -948,19 +1482,23 @@ cb_Backend_document_get_and_lock(VALUE self, VALUE bucket, VALUE collection, VAL
 }
 
 static VALUE
-cb_Backend_document_get_and_touch(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE expiry)
+cb_Backend_document_get_and_touch(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE expiry, 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(bucket, T_STRING);
     Check_Type(collection, T_STRING);
     Check_Type(id, T_STRING);
     Check_Type(expiry, T_FIXNUM);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
@@ -970,15 +1508,19 @@ cb_Backend_document_get_and_touch(VALUE self, VALUE bucket, VALUE collection, VA
         doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
 
         couchbase::operations::get_and_touch_request req{ doc_id };
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.expiry = NUM2UINT(expiry);
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::get_and_touch_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute(req, [barrier](couchbase::operations::get_and_touch_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute(req,
+                                  [barrier](couchbase::operations::get_and_touch_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable fetch and touch {} (opaque={})", doc_id, resp.opaque));
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable fetch and touch "{}" (opaque={}))", doc_id, resp.opaque));
             break;
         }
 
@@ -1010,19 +1552,23 @@ cb__extract_mutation_result(Response resp)
 }
 
 static VALUE
-cb_Backend_document_touch(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE expiry)
+cb_Backend_document_touch(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE expiry, 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(bucket, T_STRING);
     Check_Type(collection, T_STRING);
     Check_Type(id, T_STRING);
     Check_Type(expiry, T_FIXNUM);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
@@ -1032,15 +1578,18 @@ cb_Backend_document_touch(VALUE self, VALUE bucket, VALUE collection, VALUE id,
         doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
 
         couchbase::operations::touch_request req{ doc_id };
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.expiry = NUM2UINT(expiry);
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::touch_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute(req, [barrier](couchbase::operations::touch_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute(req, [barrier](couchbase::operations::touch_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to touch {} (opaque={})", doc_id, resp.opaque));
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to touch "{}" (opaque={}))", doc_id, resp.opaque));
             break;
         }
 
@@ -1053,18 +1602,22 @@ cb_Backend_document_touch(VALUE self, VALUE bucket, VALUE collection, VALUE id,
 }
 
 static VALUE
-cb_Backend_document_exists(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout)
+cb_Backend_document_exists(VALUE self, VALUE bucket, VALUE collection, VALUE id, 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(bucket, T_STRING);
     Check_Type(collection, T_STRING);
     Check_Type(id, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
@@ -1074,14 +1627,17 @@ cb_Backend_document_exists(VALUE self, VALUE bucket, VALUE collection, VALUE id,
         doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
 
         couchbase::operations::exists_request req{ doc_id };
-        cb__extract_timeout(req, timeout);
-
+        exc = cb__extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+
         auto barrier = std::make_shared<std::promise<couchbase::operations::exists_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute(req, [barrier](couchbase::operations::exists_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute(req, [barrier](couchbase::operations::exists_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to exists {} (opaque={})", doc_id, resp.opaque));
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to exists "{}" (opaque={}))", doc_id, resp.opaque));
             break;
         }
 
@@ -1112,18 +1668,22 @@ cb_Backend_document_exists(VALUE self, VALUE bucket, VALUE collection, VALUE id,
 }
 
 static VALUE
-cb_Backend_document_unlock(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE cas)
+cb_Backend_document_unlock(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE cas, 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(bucket, T_STRING);
     Check_Type(collection, T_STRING);
     Check_Type(id, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
@@ -1133,22 +1693,28 @@ cb_Backend_document_unlock(VALUE self, VALUE bucket, VALUE collection, VALUE id,
         doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
 
         couchbase::operations::unlock_request req{ doc_id };
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
         switch (TYPE(cas)) {
             case T_FIXNUM:
             case T_BIGNUM:
                 req.cas = NUM2ULL(cas);
                 break;
             default:
-                rb_raise(rb_eArgError, "CAS must be an Integer");
+                exc = rb_exc_new_str(rb_eArgError, rb_sprintf("CAS must be an Integer, but given %+" PRIsVALUE, cas));
+        }
+        if (!NIL_P(exc)) {
+            break;
         }
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::unlock_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute(req, [barrier](couchbase::operations::unlock_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute(req, [barrier](couchbase::operations::unlock_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to unlock {} (opaque={})", doc_id, resp.opaque));
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to unlock "{}" (opaque={}))", doc_id, resp.opaque));
             break;
         }
 
@@ -1161,13 +1727,14 @@ cb_Backend_document_unlock(VALUE self, VALUE bucket, VALUE collection, VALUE id,
 }
 
 static VALUE
-cb_Backend_document_upsert(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE content, VALUE flags, VALUE options)
+cb_Backend_document_upsert(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE content, VALUE flags, 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(bucket, T_STRING);
@@ -1175,6 +1742,9 @@ cb_Backend_document_upsert(VALUE self, VALUE bucket, VALUE collection, VALUE id,
     Check_Type(id, T_STRING);
     Check_Type(content, T_STRING);
     Check_Type(flags, T_FIXNUM);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
@@ -1185,45 +1755,209 @@ cb_Backend_document_upsert(VALUE self, VALUE bucket, VALUE collection, VALUE id,
         std::string value(RSTRING_PTR(content), static_cast<size_t>(RSTRING_LEN(content)));
 
         couchbase::operations::upsert_request req{ doc_id, value };
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.flags = FIX2UINT(flags);
 
-        if (!NIL_P(options)) {
-            Check_Type(options, T_HASH);
-            VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
-            if (!NIL_P(durability_level)) {
-                Check_Type(durability_level, T_SYMBOL);
-                ID level = rb_sym2id(durability_level);
-                if (level == rb_intern("none")) {
-                    req.durability_level = couchbase::protocol::durability_level::none;
-                } else if (level == rb_intern("majority")) {
-                    req.durability_level = couchbase::protocol::durability_level::majority;
-                } else if (level == rb_intern("majority_and_persist_to_active")) {
-                    req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
-                } else if (level == rb_intern("persist_to_majority")) {
-                    req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
-                } else {
-                    rb_raise(rb_eArgError, "Unknown durability level");
-                }
-                VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
-                if (!NIL_P(durability_timeout)) {
-                    Check_Type(durability_timeout, T_FIXNUM);
-                    req.durability_timeout = FIX2UINT(durability_timeout);
-                }
+        exc = cb__extract_durability(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+        VALUE expiry = Qnil;
+        exc = cb__extract_option_fixnum(expiry, options, "expiry");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        if (!NIL_P(expiry)) {
+            req.expiry = FIX2UINT(expiry);
+        }
+
+        auto barrier = std::make_shared<std::promise<couchbase::operations::upsert_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute(req, [barrier](couchbase::operations::upsert_response&& resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to upsert "{}" (opaque={}))", doc_id, resp.opaque));
+            break;
+        }
+
+        return cb__extract_mutation_result(resp);
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_document_upsert_multi(VALUE self, VALUE id_content, 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;
+    }
+
+    VALUE exc = Qnil;
+    do {
+        std::chrono::milliseconds timeout{ 0 };
+        exc = cb__extract_timeout(timeout, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+
+        couchbase::protocol::durability_level durability_level{ couchbase::protocol::durability_level::none };
+        std::optional<std::uint16_t> durability_timeout{ std::nullopt };
+        exc = cb__extract_durability(durability_level, durability_timeout, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+        VALUE expiry = Qnil;
+        exc = cb__extract_option_fixnum(expiry, options, "expiry");
+        if (!NIL_P(exc)) {
+            break;
+        }
+
+        std::vector<std::tuple<couchbase::document_id, std::string, std::uint32_t>> tuples{};
+        exc = cb__extract_array_of_id_content(tuples, id_content);
+        if (!NIL_P(exc)) {
+            break;
+        }
+
+        auto num_of_tuples = tuples.size();
+        std::vector<std::shared_ptr<std::promise<couchbase::operations::upsert_response>>> barriers;
+        barriers.reserve(num_of_tuples);
+
+        for (auto& tuple : tuples) {
+            couchbase::operations::upsert_request req{ std::move(std::get<0>(tuple)), std::move(std::get<1>(tuple)) };
+            if (timeout.count() > 0) {
+                req.timeout = timeout;
             }
-            VALUE expiry = rb_hash_aref(options, rb_id2sym(rb_intern("expiry")));
+            req.flags = std::get<2>(tuple);
+            req.durability_level = durability_level;
+            req.durability_timeout = durability_timeout;
             if (!NIL_P(expiry)) {
-                Check_Type(expiry, T_FIXNUM);
                 req.expiry = FIX2UINT(expiry);
             }
+            auto barrier = std::make_shared<std::promise<couchbase::operations::upsert_response>>();
+            backend->cluster->execute(req, [barrier](couchbase::operations::upsert_response&& resp) mutable { barrier->set_value(resp); });
+            barriers.emplace_back(barrier);
         }
 
-        auto barrier = std::make_shared<std::promise<couchbase::operations::upsert_response>>();
+        VALUE res = rb_ary_new_capa(static_cast<long>(num_of_tuples));
+        for (auto& barrier : barriers) {
+            auto resp = barrier->get_future().get();
+            VALUE entry = cb__extract_mutation_result(resp);
+            if (resp.ec) {
+                rb_hash_aset(entry,
+                             rb_id2sym(rb_intern("error")),
+                             cb__map_error_code(resp.ec, fmt::format(R"(unable upsert "{}" (opaque={}))", resp.id, resp.opaque)));
+            }
+            rb_ary_push(res, entry);
+        }
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_document_append(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE content, 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(bucket, T_STRING);
+    Check_Type(collection, T_STRING);
+    Check_Type(id, T_STRING);
+    Check_Type(content, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::document_id doc_id;
+        doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
+        doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
+        doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
+        std::string value(RSTRING_PTR(content), static_cast<size_t>(RSTRING_LEN(content)));
+
+        couchbase::operations::append_request req{ doc_id, value };
+        exc = cb__extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+        exc = cb__extract_durability(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+
+        auto barrier = std::make_shared<std::promise<couchbase::operations::append_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute(req, [barrier](couchbase::operations::append_response&& resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to append to "{}" (opaque={}))", doc_id, resp.opaque));
+            break;
+        }
+
+        return cb__extract_mutation_result(resp);
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_document_prepend(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE content, 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(bucket, T_STRING);
+    Check_Type(collection, T_STRING);
+    Check_Type(id, T_STRING);
+    Check_Type(content, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::document_id doc_id;
+        doc_id.bucket.assign(RSTRING_PTR(bucket), static_cast<size_t>(RSTRING_LEN(bucket)));
+        doc_id.collection.assign(RSTRING_PTR(collection), static_cast<size_t>(RSTRING_LEN(collection)));
+        doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
+        std::string value(RSTRING_PTR(content), static_cast<size_t>(RSTRING_LEN(content)));
+
+        couchbase::operations::prepend_request req{ doc_id, value };
+        exc = cb__extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+        exc = cb__extract_durability(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+
+        auto barrier = std::make_shared<std::promise<couchbase::operations::prepend_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute(req, [barrier](couchbase::operations::upsert_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute(req, [barrier](couchbase::operations::prepend_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to upsert {} (opaque={})", doc_id, resp.opaque));
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to prepend to "{}" (opaque={}))", doc_id, resp.opaque));
             break;
         }
 
@@ -1234,13 +1968,14 @@ cb_Backend_document_upsert(VALUE self, VALUE bucket, VALUE collection, VALUE id,
 }
 
 static VALUE
-cb_Backend_document_replace(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE content, VALUE flags, VALUE options)
+cb_Backend_document_replace(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE content, VALUE flags, 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(bucket, T_STRING);
@@ -1248,6 +1983,9 @@ cb_Backend_document_replace(VALUE self, VALUE bucket, VALUE collection, VALUE id
     Check_Type(id, T_STRING);
     Check_Type(content, T_STRING);
     Check_Type(flags, T_FIXNUM);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
@@ -1258,56 +1996,39 @@ cb_Backend_document_replace(VALUE self, VALUE bucket, VALUE collection, VALUE id
         std::string value(RSTRING_PTR(content), static_cast<size_t>(RSTRING_LEN(content)));
 
         couchbase::operations::replace_request req{ doc_id, value };
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.flags = FIX2UINT(flags);
 
-        if (!NIL_P(options)) {
-            Check_Type(options, T_HASH);
-            VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
-            if (!NIL_P(durability_level)) {
-                Check_Type(durability_level, T_SYMBOL);
-                ID level = rb_sym2id(durability_level);
-                if (level == rb_intern("none")) {
-                    req.durability_level = couchbase::protocol::durability_level::none;
-                } else if (level == rb_intern("majority")) {
-                    req.durability_level = couchbase::protocol::durability_level::majority;
-                } else if (level == rb_intern("majority_and_persist_to_active")) {
-                    req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
-                } else if (level == rb_intern("persist_to_majority")) {
-                    req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
-                } else {
-                    rb_raise(rb_eArgError, "Unknown durability level");
-                }
-                VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
-                if (!NIL_P(durability_timeout)) {
-                    Check_Type(durability_timeout, T_FIXNUM);
-                    req.durability_timeout = FIX2UINT(durability_timeout);
-                }
-            }
-            VALUE expiry = rb_hash_aref(options, rb_id2sym(rb_intern("expiry")));
-            if (!NIL_P(expiry)) {
-                Check_Type(expiry, T_FIXNUM);
-                req.expiry = FIX2UINT(expiry);
-            }
-            VALUE cas = rb_hash_aref(options, rb_id2sym(rb_intern("cas")));
-            if (!NIL_P(cas)) {
-                switch (TYPE(cas)) {
-                    case T_FIXNUM:
-                    case T_BIGNUM:
-                        req.cas = NUM2ULL(cas);
-                        break;
-                    default:
-                        rb_raise(rb_eArgError, "CAS must be an Integer");
-                }
-            }
+        exc = cb__extract_durability(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+        VALUE expiry = Qnil;
+        exc = cb__extract_option_fixnum(expiry, options, "expiry");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        if (!NIL_P(expiry)) {
+            req.expiry = FIX2UINT(expiry);
+        }
+        VALUE cas = Qnil;
+        exc = cb__extract_option_bignum(cas, options, "cas");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        if (!NIL_P(cas)) {
+            req.cas = NUM2ULL(cas);
         }
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::replace_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute(req, [barrier](couchbase::operations::replace_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute(req, [barrier](couchbase::operations::replace_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to replace {} (opaque={})", doc_id, resp.opaque));
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to replace "{}" (opaque={}))", doc_id, resp.opaque));
             break;
         }
 
@@ -1318,13 +2039,14 @@ cb_Backend_document_replace(VALUE self, VALUE bucket, VALUE collection, VALUE id
 }
 
 static VALUE
-cb_Backend_document_insert(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE content, VALUE flags, VALUE options)
+cb_Backend_document_insert(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE content, VALUE flags, 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(bucket, T_STRING);
@@ -1332,6 +2054,9 @@ cb_Backend_document_insert(VALUE self, VALUE bucket, VALUE collection, VALUE id,
     Check_Type(id, T_STRING);
     Check_Type(content, T_STRING);
     Check_Type(flags, T_FIXNUM);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
@@ -1342,45 +2067,31 @@ cb_Backend_document_insert(VALUE self, VALUE bucket, VALUE collection, VALUE id,
         std::string value(RSTRING_PTR(content), static_cast<size_t>(RSTRING_LEN(content)));
 
         couchbase::operations::insert_request req{ doc_id, value };
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.flags = FIX2UINT(flags);
 
-        if (!NIL_P(options)) {
-            Check_Type(options, T_HASH);
-            VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
-            if (!NIL_P(durability_level)) {
-                Check_Type(durability_level, T_SYMBOL);
-                ID level = rb_sym2id(durability_level);
-                if (level == rb_intern("none")) {
-                    req.durability_level = couchbase::protocol::durability_level::none;
-                } else if (level == rb_intern("majority")) {
-                    req.durability_level = couchbase::protocol::durability_level::majority;
-                } else if (level == rb_intern("majority_and_persist_to_active")) {
-                    req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
-                } else if (level == rb_intern("persist_to_majority")) {
-                    req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
-                } else {
-                    rb_raise(rb_eArgError, "Unknown durability level");
-                }
-                VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
-                if (!NIL_P(durability_timeout)) {
-                    Check_Type(durability_timeout, T_FIXNUM);
-                    req.durability_timeout = FIX2UINT(durability_timeout);
-                }
-            }
-            VALUE expiry = rb_hash_aref(options, rb_id2sym(rb_intern("expiry")));
-            if (!NIL_P(expiry)) {
-                Check_Type(expiry, T_FIXNUM);
-                req.expiry = FIX2UINT(expiry);
-            }
+        exc = cb__extract_durability(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+        VALUE expiry = Qnil;
+        exc = cb__extract_option_fixnum(expiry, options, "expiry");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        if (!NIL_P(expiry)) {
+            req.expiry = FIX2UINT(expiry);
         }
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::insert_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute(req, [barrier](couchbase::operations::insert_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute(req, [barrier](couchbase::operations::insert_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to insert {} (opaque={})", doc_id, resp.opaque));
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to insert "{}" (opaque={}))", doc_id, resp.opaque));
             break;
         }
 
@@ -1391,18 +2102,22 @@ cb_Backend_document_insert(VALUE self, VALUE bucket, VALUE collection, VALUE id,
 }
 
 static VALUE
-cb_Backend_document_remove(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE options)
+cb_Backend_document_remove(VALUE self, VALUE bucket, VALUE collection, VALUE id, 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(bucket, T_STRING);
     Check_Type(collection, T_STRING);
     Check_Type(id, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
@@ -1412,38 +2127,29 @@ cb_Backend_document_remove(VALUE self, VALUE bucket, VALUE collection, VALUE id,
         doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
 
         couchbase::operations::remove_request req{ doc_id };
-        cb__extract_timeout(req, timeout);
-        if (!NIL_P(options)) {
-            Check_Type(options, T_HASH);
-            VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
-            if (!NIL_P(durability_level)) {
-                Check_Type(durability_level, T_SYMBOL);
-                ID level = rb_sym2id(durability_level);
-                if (level == rb_intern("none")) {
-                    req.durability_level = couchbase::protocol::durability_level::none;
-                } else if (level == rb_intern("majority")) {
-                    req.durability_level = couchbase::protocol::durability_level::majority;
-                } else if (level == rb_intern("majority_and_persist_to_active")) {
-                    req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
-                } else if (level == rb_intern("persist_to_majority")) {
-                    req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
-                } else {
-                    rb_raise(rb_eArgError, "Unknown durability level");
-                }
-                VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
-                if (!NIL_P(durability_timeout)) {
-                    Check_Type(durability_timeout, T_FIXNUM);
-                    req.durability_timeout = FIX2UINT(durability_timeout);
-                }
-            }
+        exc = cb__extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+        exc = cb__extract_durability(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+        VALUE cas = Qnil;
+        exc = cb__extract_option_bignum(cas, options, "cas");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        if (!NIL_P(cas)) {
+            req.cas = NUM2ULL(cas);
         }
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::remove_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute(req, [barrier](couchbase::operations::remove_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute(req, [barrier](couchbase::operations::remove_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to remove {} (opaque={})", doc_id, resp.opaque));
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to remove "{}" (opaque={}))", doc_id, resp.opaque));
             break;
         }
         return cb__extract_mutation_result(resp);
@@ -1453,18 +2159,93 @@ cb_Backend_document_remove(VALUE self, VALUE bucket, VALUE collection, VALUE id,
 }
 
 static VALUE
-cb_Backend_document_increment(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE options)
+cb_Backend_document_remove_multi(VALUE self, VALUE id_cas, 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 {
+        std::chrono::milliseconds timeout{ 0 };
+        exc = cb__extract_timeout(timeout, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+
+        couchbase::protocol::durability_level durability_level{ couchbase::protocol::durability_level::none };
+        std::optional<std::uint16_t> durability_timeout{ std::nullopt };
+        exc = cb__extract_durability(durability_level, durability_timeout, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+
+        std::vector<std::pair<couchbase::document_id, std::uint64_t>> tuples{};
+        exc = cb__extract_array_of_id_cas(tuples, id_cas);
+        if (!NIL_P(exc)) {
+            break;
+        }
+
+        auto num_of_tuples = tuples.size();
+        std::vector<std::shared_ptr<std::promise<couchbase::operations::remove_response>>> barriers;
+        barriers.reserve(num_of_tuples);
+
+        for (auto& tuple : tuples) {
+            couchbase::operations::remove_request req{ std::move(tuple.first) };
+            req.cas = tuple.second;
+            if (timeout.count() > 0) {
+                req.timeout = timeout;
+            }
+            req.durability_level = durability_level;
+            req.durability_timeout = durability_timeout;
+            auto barrier = std::make_shared<std::promise<couchbase::operations::remove_response>>();
+            backend->cluster->execute(req, [barrier](couchbase::operations::remove_response&& resp) mutable { barrier->set_value(resp); });
+            barriers.emplace_back(barrier);
+        }
+
+        VALUE res = rb_ary_new_capa(static_cast<long>(num_of_tuples));
+        for (auto& barrier : barriers) {
+            auto resp = barrier->get_future().get();
+            VALUE entry = cb__extract_mutation_result(resp);
+            if (resp.ec) {
+                rb_hash_aset(entry,
+                             rb_id2sym(rb_intern("error")),
+                             cb__map_error_code(resp.ec, fmt::format(R"(unable remove "{}" (opaque={}))", resp.id, resp.opaque)));
+            }
+            rb_ary_push(res, entry);
+        }
+
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_document_increment(VALUE self, VALUE bucket, VALUE collection, VALUE id, 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(bucket, T_STRING);
     Check_Type(collection, T_STRING);
     Check_Type(id, T_STRING);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
@@ -1474,65 +2255,45 @@ cb_Backend_document_increment(VALUE self, VALUE bucket, VALUE collection, VALUE
         doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
 
         couchbase::operations::increment_request req{ doc_id };
-        cb__extract_timeout(req, timeout);
-        if (!NIL_P(options)) {
-            Check_Type(options, T_HASH);
-            VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
-            if (!NIL_P(durability_level)) {
-                Check_Type(durability_level, T_SYMBOL);
-                ID level = rb_sym2id(durability_level);
-                if (level == rb_intern("none")) {
-                    req.durability_level = couchbase::protocol::durability_level::none;
-                } else if (level == rb_intern("majority")) {
-                    req.durability_level = couchbase::protocol::durability_level::majority;
-                } else if (level == rb_intern("majority_and_persist_to_active")) {
-                    req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
-                } else if (level == rb_intern("persist_to_majority")) {
-                    req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
-                } else {
-                    rb_raise(rb_eArgError, "Unknown durability level");
-                }
-                VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
-                if (!NIL_P(durability_timeout)) {
-                    Check_Type(durability_timeout, T_FIXNUM);
-                    req.durability_timeout = FIX2UINT(durability_timeout);
-                }
-            }
-            VALUE delta = rb_hash_aref(options, rb_id2sym(rb_intern("delta")));
-            if (!NIL_P(delta)) {
-                switch (TYPE(delta)) {
-                    case T_FIXNUM:
-                    case T_BIGNUM:
-                        req.delta = NUM2ULL(delta);
-                        break;
-                    default:
-                        rb_raise(rb_eArgError, "delta must be an Integer");
-                }
-            }
-            VALUE initial_value = rb_hash_aref(options, rb_id2sym(rb_intern("initial_value")));
-            if (!NIL_P(initial_value)) {
-                switch (TYPE(initial_value)) {
-                    case T_FIXNUM:
-                    case T_BIGNUM:
-                        req.initial_value = NUM2ULL(initial_value);
-                        break;
-                    default:
-                        rb_raise(rb_eArgError, "initial_value must be an Integer");
-                }
-            }
-            VALUE expiry = rb_hash_aref(options, rb_id2sym(rb_intern("expiry")));
-            if (!NIL_P(expiry)) {
-                Check_Type(expiry, T_FIXNUM);
-                req.expiry = FIX2UINT(expiry);
-            }
+        exc = cb__extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+        exc = cb__extract_durability(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+        VALUE delta = Qnil;
+        exc = cb__extract_option_bignum(delta, options, "delta");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        if (!NIL_P(delta)) {
+            req.delta = NUM2ULL(delta);
+        }
+        VALUE initial_value = Qnil;
+        exc = cb__extract_option_bignum(initial_value, options, "initial_value");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        if (!NIL_P(initial_value)) {
+            req.initial_value = NUM2ULL(initial_value);
+        }
+        VALUE expiry = Qnil;
+        exc = cb__extract_option_fixnum(expiry, options, "expiry");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        if (!NIL_P(expiry)) {
+            req.expiry = FIX2UINT(expiry);
         }
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::increment_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute(req, [barrier](couchbase::operations::increment_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute(req, [barrier](couchbase::operations::increment_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to increment {} by {} (opaque={})", doc_id, req.delta, resp.opaque));
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to increment "{}" by {} (opaque={}))", doc_id, req.delta, resp.opaque));
             break;
         }
         VALUE res = cb__extract_mutation_result(resp);
@@ -1544,19 +2305,22 @@ cb_Backend_document_increment(VALUE self, VALUE bucket, VALUE collection, VALUE
 }
 
 static VALUE
-cb_Backend_document_decrement(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE options)
+cb_Backend_document_decrement(VALUE self, VALUE bucket, VALUE collection, VALUE id, 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(bucket, T_STRING);
     Check_Type(collection, T_STRING);
     Check_Type(id, T_STRING);
-    Check_Type(options, T_HASH);
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
 
     VALUE exc = Qnil;
     do {
@@ -1566,65 +2330,45 @@ cb_Backend_document_decrement(VALUE self, VALUE bucket, VALUE collection, VALUE
         doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
 
         couchbase::operations::decrement_request req{ doc_id };
-        cb__extract_timeout(req, timeout);
-        if (!NIL_P(options)) {
-            Check_Type(options, T_HASH);
-            VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
-            if (!NIL_P(durability_level)) {
-                Check_Type(durability_level, T_SYMBOL);
-                ID level = rb_sym2id(durability_level);
-                if (level == rb_intern("none")) {
-                    req.durability_level = couchbase::protocol::durability_level::none;
-                } else if (level == rb_intern("majority")) {
-                    req.durability_level = couchbase::protocol::durability_level::majority;
-                } else if (level == rb_intern("majority_and_persist_to_active")) {
-                    req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
-                } else if (level == rb_intern("persist_to_majority")) {
-                    req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
-                } else {
-                    rb_raise(rb_eArgError, "Unknown durability level");
-                }
-                VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
-                if (!NIL_P(durability_timeout)) {
-                    Check_Type(durability_timeout, T_FIXNUM);
-                    req.durability_timeout = FIX2UINT(durability_timeout);
-                }
-            }
-            VALUE delta = rb_hash_aref(options, rb_id2sym(rb_intern("delta")));
-            if (!NIL_P(delta)) {
-                switch (TYPE(delta)) {
-                    case T_FIXNUM:
-                    case T_BIGNUM:
-                        req.delta = NUM2ULL(delta);
-                        break;
-                    default:
-                        rb_raise(rb_eArgError, "delta must be an Integer");
-                }
-            }
-            VALUE initial_value = rb_hash_aref(options, rb_id2sym(rb_intern("initial_value")));
-            if (!NIL_P(initial_value)) {
-                switch (TYPE(initial_value)) {
-                    case T_FIXNUM:
-                    case T_BIGNUM:
-                        req.initial_value = NUM2ULL(initial_value);
-                        break;
-                    default:
-                        rb_raise(rb_eArgError, "initial_value must be an Integer");
-                }
-            }
-            VALUE expiry = rb_hash_aref(options, rb_id2sym(rb_intern("expiry")));
-            if (!NIL_P(expiry)) {
-                Check_Type(expiry, T_FIXNUM);
-                req.expiry = FIX2UINT(expiry);
-            }
+        exc = cb__extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+        exc = cb__extract_durability(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+        VALUE delta = Qnil;
+        exc = cb__extract_option_bignum(delta, options, "delta");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        if (!NIL_P(delta)) {
+            req.delta = NUM2ULL(delta);
+        }
+        VALUE initial_value = Qnil;
+        exc = cb__extract_option_bignum(initial_value, options, "initial_value");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        if (!NIL_P(initial_value)) {
+            req.initial_value = NUM2ULL(initial_value);
+        }
+        VALUE expiry = Qnil;
+        exc = cb__extract_option_fixnum(expiry, options, "expiry");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        if (!NIL_P(expiry)) {
+            req.expiry = FIX2UINT(expiry);
         }
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::decrement_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute(req, [barrier](couchbase::operations::decrement_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute(req, [barrier](couchbase::operations::decrement_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to decrement {} by {} (opaque={})", doc_id, req.delta, resp.opaque));
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to decrement "{}" by {} (opaque={}))", doc_id, req.delta, resp.opaque));
             break;
         }
         VALUE res = cb__extract_mutation_result(resp);
@@ -1680,6 +2424,9 @@ cb__map_subdoc_opcode(couchbase::protocol::subdoc_opcode opcode)
 
         case couchbase::protocol::subdoc_opcode::set_doc:
             return rb_id2sym(rb_intern("set_doc"));
+
+        case couchbase::protocol::subdoc_opcode::replace_body_with_xattr:
+            return rb_id2sym(rb_intern("replace_body_with_xattr"));
     }
     return rb_id2sym(rb_intern("unknown"));
 }
@@ -1807,13 +2554,14 @@ cb__map_subdoc_status(couchbase::protocol::status status, std::size_t index, con
 }
 
 static VALUE
-cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE access_deleted, VALUE specs)
+cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE specs, 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(bucket, T_STRING);
@@ -1822,6 +2570,10 @@ cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE collection, VALUE
     Check_Type(specs, T_ARRAY);
     if (RARRAY_LEN(specs) <= 0) {
         rb_raise(rb_eArgError, "Array with specs cannot be empty");
+        return Qnil;
+    }
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
     }
 
     VALUE exc = Qnil;
@@ -1832,8 +2584,14 @@ cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE collection, VALUE
         doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
 
         couchbase::operations::lookup_in_request req{ doc_id };
-        cb__extract_timeout(req, timeout);
-        req.access_deleted = RTEST(access_deleted);
+        exc = cb__extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+        exc = cb__extract_option_bool(req.access_deleted, options, "access_deleted");
+        if (!NIL_P(exc)) {
+            break;
+        }
         auto entries_size = static_cast<size_t>(RARRAY_LEN(specs));
         req.specs.entries.reserve(entries_size);
         for (size_t i = 0; i < entries_size; ++i) {
@@ -1852,20 +2610,24 @@ cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE collection, VALUE
             } else if (operation_id == rb_intern("count")) {
                 opcode = couchbase::protocol::subdoc_opcode::get_count;
             } else {
-                rb_raise(rb_eArgError, "Unsupported operation for subdocument lookup");
+                exc = rb_exc_new_str(eInvalidArgument, rb_sprintf("unsupported operation for subdocument lookup: %+" PRIsVALUE, operation));
+                break;
             }
             bool xattr = RTEST(rb_hash_aref(entry, rb_id2sym(rb_intern("xattr"))));
             VALUE path = rb_hash_aref(entry, rb_id2sym(rb_intern("path")));
             Check_Type(path, T_STRING);
             req.specs.add_spec(opcode, xattr, std::string(RSTRING_PTR(path), static_cast<size_t>(RSTRING_LEN(path))));
         }
+        if (!NIL_P(exc)) {
+            break;
+        }
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::lookup_in_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute(req, [barrier](couchbase::operations::lookup_in_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute(req, [barrier](couchbase::operations::lookup_in_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable fetch {} (opaque={})", doc_id, resp.opaque));
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable fetch "{}" (opaque={}))", doc_id, resp.opaque));
             break;
         }
 
@@ -1873,6 +2635,9 @@ cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE collection, VALUE
         rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
         VALUE fields = rb_ary_new_capa(static_cast<long>(resp.fields.size()));
         rb_hash_aset(res, rb_id2sym(rb_intern("fields")), fields);
+        if (resp.deleted) {
+            rb_hash_aset(res, rb_id2sym(rb_intern("deleted")), Qtrue);
+        }
         for (size_t i = 0; i < resp.fields.size(); ++i) {
             VALUE entry = rb_hash_new();
             rb_hash_aset(entry, rb_id2sym(rb_intern("index")), ULL2NUM(i));
@@ -1897,13 +2662,14 @@ cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE collection, VALUE
 }
 
 static VALUE
-cb_Backend_document_mutate_in(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE timeout, VALUE specs, VALUE options)
+cb_Backend_document_mutate_in(VALUE self, VALUE bucket, VALUE collection, VALUE id, VALUE specs, 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(bucket, T_STRING);
@@ -1912,6 +2678,10 @@ cb_Backend_document_mutate_in(VALUE self, VALUE bucket, VALUE collection, VALUE
     Check_Type(specs, T_ARRAY);
     if (RARRAY_LEN(specs) <= 0) {
         rb_raise(rb_eArgError, "Array with specs cannot be empty");
+        return Qnil;
+    }
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
     }
 
     VALUE exc = Qnil;
@@ -1922,62 +2692,50 @@ cb_Backend_document_mutate_in(VALUE self, VALUE bucket, VALUE collection, VALUE
         doc_id.key.assign(RSTRING_PTR(id), static_cast<size_t>(RSTRING_LEN(id)));
 
         couchbase::operations::mutate_in_request req{ doc_id };
-        cb__extract_timeout(req, timeout);
-        if (!NIL_P(options)) {
-            Check_Type(options, T_HASH);
-            VALUE durability_level = rb_hash_aref(options, rb_id2sym(rb_intern("durability_level")));
-            if (!NIL_P(durability_level)) {
-                Check_Type(durability_level, T_SYMBOL);
-                ID level = rb_sym2id(durability_level);
-                if (level == rb_intern("none")) {
-                    req.durability_level = couchbase::protocol::durability_level::none;
-                } else if (level == rb_intern("majority")) {
-                    req.durability_level = couchbase::protocol::durability_level::majority;
-                } else if (level == rb_intern("majority_and_persist_to_active")) {
-                    req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
-                } else if (level == rb_intern("persist_to_majority")) {
-                    req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
-                } else {
-                    rb_raise(rb_eArgError, "Unknown durability level");
-                }
-                VALUE durability_timeout = rb_hash_aref(options, rb_id2sym(rb_intern("durability_timeout")));
-                if (!NIL_P(durability_timeout)) {
-                    Check_Type(durability_timeout, T_FIXNUM);
-                    req.durability_timeout = FIX2UINT(durability_timeout);
-                }
-            }
-            VALUE access_deleted = rb_hash_aref(options, rb_id2sym(rb_intern("access_deleted")));
-            if (!NIL_P(access_deleted)) {
-                req.access_deleted = RTEST(access_deleted);
-            }
-            VALUE store_semantics = rb_hash_aref(options, rb_id2sym(rb_intern("store_semantics")));
-            if (!NIL_P(store_semantics)) {
-                Check_Type(store_semantics, T_SYMBOL);
-                ID semantics = rb_sym2id(store_semantics);
-                if (semantics == rb_intern("replace")) {
-                    req.store_semantics = couchbase::protocol::mutate_in_request_body::store_semantics_type::replace;
-                } else if (semantics == rb_intern("insert")) {
-                    req.store_semantics = couchbase::protocol::mutate_in_request_body::store_semantics_type::insert;
-                } else if (semantics == rb_intern("upsert")) {
-                    req.store_semantics = couchbase::protocol::mutate_in_request_body::store_semantics_type::upsert;
-                }
-            }
-            VALUE expiry = rb_hash_aref(options, rb_id2sym(rb_intern("expiry")));
-            if (!NIL_P(expiry)) {
-                Check_Type(expiry, T_FIXNUM);
-                req.expiry = FIX2UINT(expiry);
-            }
-            VALUE cas = rb_hash_aref(options, rb_id2sym(rb_intern("cas")));
-            if (!NIL_P(cas)) {
-                switch (TYPE(cas)) {
-                    case T_FIXNUM:
-                    case T_BIGNUM:
-                        req.cas = NUM2ULL(cas);
-                        break;
-                    default:
-                        rb_raise(rb_eArgError, "CAS must be an Integer");
-                }
-            }
+        exc = cb__extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+        exc = cb__extract_durability(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
+        VALUE cas = Qnil;
+        exc = cb__extract_option_bignum(cas, options, "cas");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        if (!NIL_P(cas)) {
+            req.cas = NUM2ULL(cas);
+        }
+        VALUE expiry = Qnil;
+        exc = cb__extract_option_fixnum(expiry, options, "expiry");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        if (!NIL_P(expiry)) {
+            req.expiry = FIX2UINT(expiry);
+        }
+        exc = cb__extract_option_bool(req.access_deleted, options, "access_deleted");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        exc = cb__extract_option_bool(req.create_as_deleted, options, "create_as_deleted");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        VALUE store_semantics = Qnil;
+        exc = cb__extract_option_symbol(store_semantics, options, "store_semantics");
+        if (!NIL_P(exc)) {
+            break;
+        }
+        ID semantics = rb_sym2id(store_semantics);
+        if (semantics == rb_intern("replace")) {
+            req.store_semantics = couchbase::protocol::mutate_in_request_body::store_semantics_type::replace;
+        } else if (semantics == rb_intern("insert")) {
+            req.store_semantics = couchbase::protocol::mutate_in_request_body::store_semantics_type::insert;
+        } else if (semantics == rb_intern("upsert")) {
+            req.store_semantics = couchbase::protocol::mutate_in_request_body::store_semantics_type::upsert;
         }
         auto entries_size = static_cast<size_t>(RARRAY_LEN(specs));
         req.specs.entries.reserve(entries_size);
@@ -2009,7 +2767,9 @@ cb_Backend_document_mutate_in(VALUE self, VALUE bucket, VALUE collection, VALUE
             } else if (operation_id == rb_intern("set_doc")) {
                 opcode = couchbase::protocol::subdoc_opcode::set_doc;
             } else {
-                rb_raise(rb_eArgError, "Unsupported operation for subdocument mutation: %+" PRIsVALUE, operation);
+                exc =
+                  rb_exc_new_str(eInvalidArgument, rb_sprintf("unsupported operation for subdocument mutation: %+" PRIsVALUE, operation));
+                break;
             }
             bool xattr = RTEST(rb_hash_aref(entry, rb_id2sym(rb_intern("xattr"))));
             bool create_path = RTEST(rb_hash_aref(entry, rb_id2sym(rb_intern("create_path"))));
@@ -2037,13 +2797,16 @@ cb_Backend_document_mutate_in(VALUE self, VALUE bucket, VALUE collection, VALUE
                                    std::string(RSTRING_PTR(param), static_cast<size_t>(RSTRING_LEN(param))));
             }
         }
+        if (!NIL_P(exc)) {
+            break;
+        }
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::mutate_in_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute(req, [barrier](couchbase::operations::mutate_in_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute(req, [barrier](couchbase::operations::mutate_in_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to mutate {} (opaque={})", doc_id, resp.opaque));
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to mutate "{}" (opaque={}))", doc_id, resp.opaque));
             break;
         }
 
@@ -2051,6 +2814,9 @@ cb_Backend_document_mutate_in(VALUE self, VALUE bucket, VALUE collection, VALUE
         if (resp.first_error_index) {
             rb_hash_aset(res, rb_id2sym(rb_intern("first_error_index")), ULONG2NUM(resp.first_error_index.value()));
         }
+        if (resp.deleted) {
+            rb_hash_aset(res, rb_id2sym(rb_intern("deleted")), Qtrue);
+        }
         VALUE fields = rb_ary_new_capa(static_cast<long>(resp.fields.size()));
         rb_hash_aset(res, rb_id2sym(rb_intern("fields")), fields);
         for (size_t i = 0; i < resp.fields.size(); ++i) {
@@ -2100,6 +2866,7 @@ cb_Backend_document_query(VALUE self, VALUE statement, VALUE options)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(statement, T_STRING);
@@ -2114,7 +2881,10 @@ cb_Backend_document_query(VALUE self, VALUE statement, VALUE options)
             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)));
         }
-        cb__extract_timeout(req, rb_hash_aref(options, rb_id2sym(rb_intern("timeout"))));
+        exc = cb__extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
         VALUE adhoc = rb_hash_aref(options, rb_id2sym(rb_intern("adhoc")));
         if (!NIL_P(adhoc)) {
             req.adhoc = RTEST(adhoc);
@@ -2250,7 +3020,7 @@ cb_Backend_document_query(VALUE self, VALUE statement, VALUE options)
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::query_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute_http(req, [barrier](couchbase::operations::query_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute_http(req, [barrier](couchbase::operations::query_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.payload.meta_data.errors && !resp.payload.meta_data.errors->empty()) {
@@ -2441,6 +3211,7 @@ cb_Backend_bucket_create(VALUE self, VALUE bucket_settings, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_settings, T_HASH);
@@ -2448,12 +3219,15 @@ cb_Backend_bucket_create(VALUE self, VALUE bucket_settings, VALUE timeout)
     VALUE exc = Qnil;
     do {
         couchbase::operations::bucket_create_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         cb__generate_bucket_settings(bucket_settings, req.bucket, true);
         auto barrier = std::make_shared<std::promise<couchbase::operations::bucket_create_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute_http(req,
-                                       [barrier](couchbase::operations::bucket_create_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::bucket_create_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(
@@ -2475,18 +3249,22 @@ cb_Backend_bucket_update(VALUE self, VALUE bucket_settings, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_settings, T_HASH);
     VALUE exc = Qnil;
     do {
         couchbase::operations::bucket_update_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         cb__generate_bucket_settings(bucket_settings, req.bucket, false);
         auto barrier = std::make_shared<std::promise<couchbase::operations::bucket_update_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute_http(req,
-                                       [barrier](couchbase::operations::bucket_update_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::bucket_update_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(
@@ -2507,6 +3285,7 @@ cb_Backend_bucket_drop(VALUE self, VALUE bucket_name, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -2514,12 +3293,15 @@ cb_Backend_bucket_drop(VALUE self, VALUE bucket_name, VALUE timeout)
     VALUE exc = Qnil;
     do {
         couchbase::operations::bucket_drop_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
         auto barrier = std::make_shared<std::promise<couchbase::operations::bucket_drop_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(req,
-                                       [barrier](couchbase::operations::bucket_drop_response resp) mutable { barrier->set_value(resp); });
+                                       [barrier](couchbase::operations::bucket_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(resp.ec, fmt::format("unable to remove bucket \"{}\" on the cluster", req.name));
@@ -2539,6 +3321,7 @@ cb_Backend_bucket_flush(VALUE self, VALUE bucket_name, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -2546,12 +3329,15 @@ cb_Backend_bucket_flush(VALUE self, VALUE bucket_name, VALUE timeout)
     VALUE exc = Qnil;
     do {
         couchbase::operations::bucket_flush_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
         auto barrier = std::make_shared<std::promise<couchbase::operations::bucket_flush_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute_http(req,
-                                       [barrier](couchbase::operations::bucket_flush_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::bucket_flush_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(resp.ec, fmt::format("unable to remove bucket \"{}\" on the cluster", req.name));
@@ -2654,16 +3440,20 @@ cb_Backend_bucket_get_all(VALUE self, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::bucket_get_all_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         auto barrier = std::make_shared<std::promise<couchbase::operations::bucket_get_all_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::bucket_get_all_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::bucket_get_all_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(resp.ec, "unable to get list of the buckets of the cluster");
@@ -2691,6 +3481,7 @@ cb_Backend_bucket_get(VALUE self, VALUE bucket_name, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -2698,12 +3489,15 @@ cb_Backend_bucket_get(VALUE self, VALUE bucket_name, VALUE timeout)
     VALUE exc = Qnil;
     do {
         couchbase::operations::bucket_get_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
         auto barrier = std::make_shared<std::promise<couchbase::operations::bucket_get_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(req,
-                                       [barrier](couchbase::operations::bucket_get_response resp) mutable { barrier->set_value(resp); });
+                                       [barrier](couchbase::operations::bucket_get_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(resp.ec, fmt::format("unable to locate bucket \"{}\" on the cluster", req.name));
@@ -2747,16 +3541,20 @@ cb_Backend_role_get_all(VALUE self, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::role_get_all_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         auto barrier = std::make_shared<std::promise<couchbase::operations::role_get_all_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute_http(req,
-                                       [barrier](couchbase::operations::role_get_all_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::role_get_all_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(resp.ec, "unable to fetch users");
@@ -2864,6 +3662,7 @@ cb_Backend_user_get_all(VALUE self, VALUE domain, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(domain, T_SYMBOL);
@@ -2871,7 +3670,10 @@ cb_Backend_user_get_all(VALUE self, VALUE domain, VALUE timeout)
     VALUE exc = Qnil;
     do {
         couchbase::operations::user_get_all_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         if (domain == rb_id2sym(rb_intern("local"))) {
             req.domain = couchbase::operations::rbac::auth_domain::local;
         } else if (domain == rb_id2sym(rb_intern("external"))) {
@@ -2882,8 +3684,8 @@ cb_Backend_user_get_all(VALUE self, VALUE domain, VALUE timeout)
         }
         auto barrier = std::make_shared<std::promise<couchbase::operations::user_get_all_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute_http(req,
-                                       [barrier](couchbase::operations::user_get_all_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::user_get_all_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(resp.ec, "unable to fetch users");
@@ -2910,6 +3712,7 @@ cb_Backend_user_get(VALUE self, VALUE domain, VALUE username, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(domain, T_SYMBOL);
@@ -2918,7 +3721,10 @@ cb_Backend_user_get(VALUE self, VALUE domain, VALUE username, VALUE timeout)
     VALUE exc = Qnil;
     do {
         couchbase::operations::user_get_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         if (domain == rb_id2sym(rb_intern("local"))) {
             req.domain = couchbase::operations::rbac::auth_domain::local;
         } else if (domain == rb_id2sym(rb_intern("external"))) {
@@ -2930,7 +3736,8 @@ cb_Backend_user_get(VALUE self, VALUE domain, VALUE username, VALUE timeout)
         req.username.assign(RSTRING_PTR(username), static_cast<size_t>(RSTRING_LEN(username)));
         auto barrier = std::make_shared<std::promise<couchbase::operations::user_get_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute_http(req, [barrier](couchbase::operations::user_get_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute_http(req,
+                                       [barrier](couchbase::operations::user_get_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to fetch user "{}")", req.username).c_str());
@@ -2953,6 +3760,7 @@ cb_Backend_user_drop(VALUE self, VALUE domain, VALUE username, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(domain, T_SYMBOL);
@@ -2961,7 +3769,10 @@ cb_Backend_user_drop(VALUE self, VALUE domain, VALUE username, VALUE timeout)
     VALUE exc = Qnil;
     do {
         couchbase::operations::user_drop_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         if (domain == rb_id2sym(rb_intern("local"))) {
             req.domain = couchbase::operations::rbac::auth_domain::local;
         } else if (domain == rb_id2sym(rb_intern("external"))) {
@@ -2974,7 +3785,7 @@ cb_Backend_user_drop(VALUE self, VALUE domain, VALUE username, VALUE timeout)
         auto barrier = std::make_shared<std::promise<couchbase::operations::user_drop_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(req,
-                                       [barrier](couchbase::operations::user_drop_response resp) mutable { barrier->set_value(resp); });
+                                       [barrier](couchbase::operations::user_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to fetch user "{}")", req.username).c_str());
@@ -2995,6 +3806,7 @@ cb_Backend_user_upsert(VALUE self, VALUE domain, VALUE user, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(domain, T_SYMBOL);
@@ -3003,7 +3815,10 @@ cb_Backend_user_upsert(VALUE self, VALUE domain, VALUE user, VALUE timeout)
     VALUE exc = Qnil;
     do {
         couchbase::operations::user_upsert_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         if (domain == rb_id2sym(rb_intern("local"))) {
             req.domain = couchbase::operations::rbac::auth_domain::local;
         } else if (domain == rb_id2sym(rb_intern("external"))) {
@@ -3015,6 +3830,7 @@ cb_Backend_user_upsert(VALUE self, VALUE domain, VALUE user, VALUE timeout)
         VALUE name = rb_hash_aref(user, rb_id2sym(rb_intern("username")));
         if (NIL_P(name) || TYPE(name) != T_STRING) {
             exc = rb_exc_new_cstr(eInvalidArgument, "unable to upsert user: missing name");
+            break;
         }
         req.user.username.assign(RSTRING_PTR(name), static_cast<size_t>(RSTRING_LEN(name)));
         VALUE display_name = rb_hash_aref(user, rb_id2sym(rb_intern("display_name")));
@@ -3065,7 +3881,7 @@ cb_Backend_user_upsert(VALUE self, VALUE domain, VALUE user, VALUE timeout)
         auto barrier = std::make_shared<std::promise<couchbase::operations::user_upsert_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(req,
-                                       [barrier](couchbase::operations::user_upsert_response resp) mutable { barrier->set_value(resp); });
+                                       [barrier](couchbase::operations::user_upsert_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(
@@ -3119,16 +3935,20 @@ cb_Backend_group_get_all(VALUE self, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::group_get_all_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         auto barrier = std::make_shared<std::promise<couchbase::operations::group_get_all_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute_http(req,
-                                       [barrier](couchbase::operations::group_get_all_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::group_get_all_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(resp.ec, "unable to fetch groups");
@@ -3155,6 +3975,7 @@ cb_Backend_group_get(VALUE self, VALUE name, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(name, T_STRING);
@@ -3162,15 +3983,18 @@ cb_Backend_group_get(VALUE self, VALUE name, VALUE timeout)
     VALUE exc = Qnil;
     do {
         couchbase::operations::group_get_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.name.assign(RSTRING_PTR(name), static_cast<size_t>(RSTRING_LEN(name)));
         auto barrier = std::make_shared<std::promise<couchbase::operations::group_get_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(req,
-                                       [barrier](couchbase::operations::group_get_response resp) mutable { barrier->set_value(resp); });
+                                       [barrier](couchbase::operations::group_get_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to fetch group "{}")", req.name).c_str());
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to fetch group "{}")", req.name));
             break;
         }
 
@@ -3190,6 +4014,7 @@ cb_Backend_group_drop(VALUE self, VALUE name, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(name, T_STRING);
@@ -3197,15 +4022,18 @@ cb_Backend_group_drop(VALUE self, VALUE name, VALUE timeout)
     VALUE exc = Qnil;
     do {
         couchbase::operations::group_drop_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.name.assign(RSTRING_PTR(name), static_cast<size_t>(RSTRING_LEN(name)));
         auto barrier = std::make_shared<std::promise<couchbase::operations::group_drop_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(req,
-                                       [barrier](couchbase::operations::group_drop_response resp) mutable { barrier->set_value(resp); });
+                                       [barrier](couchbase::operations::group_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to drop group "{}")", req.name).c_str());
+            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to drop group "{}")", req.name));
             break;
         }
 
@@ -3223,6 +4051,7 @@ cb_Backend_group_upsert(VALUE self, VALUE group, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(group, T_HASH);
@@ -3230,10 +4059,14 @@ cb_Backend_group_upsert(VALUE self, VALUE group, VALUE timeout)
     VALUE exc = Qnil;
     do {
         couchbase::operations::group_upsert_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         VALUE name = rb_hash_aref(group, rb_id2sym(rb_intern("name")));
         if (NIL_P(name) || TYPE(name) != T_STRING) {
             exc = rb_exc_new_cstr(eInvalidArgument, "unable to upsert group: missing name");
+            break;
         }
         req.group.name.assign(RSTRING_PTR(name), static_cast<size_t>(RSTRING_LEN(name)));
         VALUE ldap_group_ref = rb_hash_aref(group, rb_id2sym(rb_intern("ldap_group_reference")));
@@ -3272,8 +4105,8 @@ cb_Backend_group_upsert(VALUE self, VALUE group, VALUE timeout)
         }
         auto barrier = std::make_shared<std::promise<couchbase::operations::group_upsert_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute_http(req,
-                                       [barrier](couchbase::operations::group_upsert_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::group_upsert_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(
@@ -3295,6 +4128,7 @@ cb_Backend_cluster_enable_developer_preview(VALUE self)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     VALUE exc = Qnil;
@@ -3303,7 +4137,7 @@ cb_Backend_cluster_enable_developer_preview(VALUE self)
         auto barrier = std::make_shared<std::promise<couchbase::operations::cluster_developer_preview_enable_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::cluster_developer_preview_enable_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::cluster_developer_preview_enable_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(resp.ec, fmt::format("unable to enable developer preview for this cluster"));
@@ -3326,6 +4160,7 @@ cb_Backend_scope_get_all(VALUE self, VALUE bucket_name, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -3333,12 +4168,15 @@ cb_Backend_scope_get_all(VALUE self, VALUE bucket_name, VALUE timeout)
     VALUE exc = Qnil;
     do {
         couchbase::operations::scope_get_all_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
         auto barrier = std::make_shared<std::promise<couchbase::operations::scope_get_all_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute_http(req,
-                                       [barrier](couchbase::operations::scope_get_all_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::scope_get_all_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(resp.ec, fmt::format("unable to get list of the scopes of the bucket \"{}\"", req.bucket_name));
@@ -3378,6 +4216,7 @@ cb_Backend_collections_manifest_get(VALUE self, VALUE bucket_name, VALUE timeout
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -3385,12 +4224,15 @@ cb_Backend_collections_manifest_get(VALUE self, VALUE bucket_name, VALUE timeout
     VALUE exc = Qnil;
     do {
         couchbase::operations::collections_manifest_get_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.id.bucket.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
         auto barrier = std::make_shared<std::promise<couchbase::operations::collections_manifest_get_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute(
-          req, [barrier](couchbase::operations::collections_manifest_get_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::collections_manifest_get_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(resp.ec, fmt::format("unable to get collections manifest of the bucket \"{}\"", req.id.bucket));
@@ -3430,6 +4272,7 @@ cb_Backend_scope_create(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE t
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -3438,13 +4281,16 @@ cb_Backend_scope_create(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE t
     VALUE exc = Qnil;
     do {
         couchbase::operations::scope_create_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
         req.scope_name.assign(RSTRING_PTR(scope_name), static_cast<size_t>(RSTRING_LEN(scope_name)));
         auto barrier = std::make_shared<std::promise<couchbase::operations::scope_create_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute_http(req,
-                                       [barrier](couchbase::operations::scope_create_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::scope_create_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(resp.ec,
@@ -3465,6 +4311,7 @@ cb_Backend_scope_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE tim
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -3473,13 +4320,16 @@ cb_Backend_scope_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE tim
     VALUE exc = Qnil;
     do {
         couchbase::operations::scope_drop_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
         req.scope_name.assign(RSTRING_PTR(scope_name), static_cast<size_t>(RSTRING_LEN(scope_name)));
         auto barrier = std::make_shared<std::promise<couchbase::operations::scope_drop_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(req,
-                                       [barrier](couchbase::operations::scope_drop_response resp) mutable { barrier->set_value(resp); });
+                                       [barrier](couchbase::operations::scope_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(resp.ec,
@@ -3500,6 +4350,7 @@ cb_Backend_collection_create(VALUE self, VALUE bucket_name, VALUE scope_name, VA
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -3509,7 +4360,10 @@ cb_Backend_collection_create(VALUE self, VALUE bucket_name, VALUE scope_name, VA
     VALUE exc = Qnil;
     do {
         couchbase::operations::collection_create_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
         req.scope_name.assign(RSTRING_PTR(scope_name), static_cast<size_t>(RSTRING_LEN(scope_name)));
         req.collection_name.assign(RSTRING_PTR(collection_name), static_cast<size_t>(RSTRING_LEN(collection_name)));
@@ -3521,7 +4375,7 @@ cb_Backend_collection_create(VALUE self, VALUE bucket_name, VALUE scope_name, VA
         auto barrier = std::make_shared<std::promise<couchbase::operations::collection_create_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::collection_create_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::collection_create_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(
@@ -3544,6 +4398,7 @@ cb_Backend_collection_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALU
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -3553,7 +4408,10 @@ cb_Backend_collection_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALU
     VALUE exc = Qnil;
     do {
         couchbase::operations::collection_drop_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
         req.scope_name.assign(RSTRING_PTR(scope_name), static_cast<size_t>(RSTRING_LEN(scope_name)));
         req.collection_name.assign(RSTRING_PTR(collection_name), static_cast<size_t>(RSTRING_LEN(collection_name)));
@@ -3561,7 +4419,7 @@ cb_Backend_collection_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALU
         auto barrier = std::make_shared<std::promise<couchbase::operations::collection_drop_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::collection_drop_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::collection_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(
@@ -3584,6 +4442,7 @@ cb_Backend_query_index_get_all(VALUE self, VALUE bucket_name, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -3591,12 +4450,15 @@ cb_Backend_query_index_get_all(VALUE self, VALUE bucket_name, VALUE timeout)
     VALUE exc = Qnil;
     do {
         couchbase::operations::query_index_get_all_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
         auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_get_all_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::query_index_get_all_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::query_index_get_all_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(resp.ec, fmt::format("unable to get list of the indexes of the bucket \"{}\"", req.bucket_name));
@@ -3655,6 +4517,7 @@ cb_Backend_query_index_create(VALUE self, VALUE bucket_name, VALUE index_name, V
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -3664,7 +4527,10 @@ cb_Backend_query_index_create(VALUE self, VALUE bucket_name, VALUE index_name, V
     VALUE exc = Qnil;
     do {
         couchbase::operations::query_index_create_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        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)));
         auto fields_num = static_cast<size_t>(RARRAY_LEN(fields));
@@ -3709,7 +4575,7 @@ cb_Backend_query_index_create(VALUE self, VALUE bucket_name, VALUE index_name, V
         auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_create_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::query_index_create_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::query_index_create_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (!resp.errors.empty()) {
@@ -3752,6 +4618,7 @@ cb_Backend_query_index_drop(VALUE self, VALUE bucket_name, VALUE index_name, VAL
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -3760,7 +4627,10 @@ cb_Backend_query_index_drop(VALUE self, VALUE bucket_name, VALUE index_name, VAL
     VALUE exc = Qnil;
     do {
         couchbase::operations::query_index_drop_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        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)) {
@@ -3784,7 +4654,7 @@ cb_Backend_query_index_drop(VALUE self, VALUE bucket_name, VALUE index_name, VAL
         auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_drop_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::query_index_drop_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::query_index_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (!resp.errors.empty()) {
@@ -3827,6 +4697,7 @@ cb_Backend_query_index_create_primary(VALUE self, VALUE bucket_name, VALUE optio
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -3837,7 +4708,10 @@ cb_Backend_query_index_create_primary(VALUE self, VALUE bucket_name, VALUE optio
     VALUE exc = Qnil;
     do {
         couchbase::operations::query_index_create_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        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)) {
@@ -3875,7 +4749,7 @@ cb_Backend_query_index_create_primary(VALUE self, VALUE bucket_name, VALUE optio
         auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_create_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::query_index_create_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::query_index_create_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (!resp.errors.empty()) {
@@ -3917,6 +4791,7 @@ cb_Backend_query_index_drop_primary(VALUE self, VALUE bucket_name, VALUE options
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -3924,7 +4799,10 @@ cb_Backend_query_index_drop_primary(VALUE self, VALUE bucket_name, VALUE options
     VALUE exc = Qnil;
     do {
         couchbase::operations::query_index_drop_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        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)) {
@@ -3954,7 +4832,7 @@ cb_Backend_query_index_drop_primary(VALUE self, VALUE bucket_name, VALUE options
         auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_drop_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::query_index_drop_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::query_index_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (!resp.errors.empty()) {
@@ -3994,6 +4872,7 @@ cb_Backend_query_index_build_deferred(VALUE self, VALUE bucket_name, VALUE timeo
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -4001,12 +4880,15 @@ cb_Backend_query_index_build_deferred(VALUE self, VALUE bucket_name, VALUE timeo
     VALUE exc = Qnil;
     do {
         couchbase::operations::query_index_build_deferred_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
         auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_build_deferred_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::query_index_build_deferred_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::query_index_build_deferred_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (!resp.errors.empty()) {
@@ -4036,6 +4918,7 @@ cb_Backend_query_index_watch(VALUE self, VALUE bucket_name, VALUE index_names, V
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -4087,16 +4970,20 @@ cb_Backend_search_index_get_all(VALUE self, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::search_index_get_all_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_get_all_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::search_index_get_all_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::search_index_get_all_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(resp.ec, "unable to get list of the search indexes");
@@ -4127,18 +5014,22 @@ cb_Backend_search_index_get(VALUE self, VALUE index_name, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(index_name, T_STRING);
     VALUE exc = Qnil;
     do {
         couchbase::operations::search_index_get_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
         auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_get_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::search_index_get_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::search_index_get_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.error.empty()) {
@@ -4164,13 +5055,17 @@ cb_Backend_search_index_upsert(VALUE self, VALUE index_definition, VALUE timeout
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(index_definition, T_HASH);
     VALUE exc = Qnil;
     do {
         couchbase::operations::search_index_upsert_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
 
         VALUE index_name = rb_hash_aref(index_definition, rb_id2sym(rb_intern("name")));
         Check_Type(index_name, T_STRING);
@@ -4223,7 +5118,7 @@ cb_Backend_search_index_upsert(VALUE self, VALUE index_definition, VALUE timeout
         auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_upsert_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::search_index_upsert_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::search_index_upsert_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.error.empty()) {
@@ -4249,18 +5144,22 @@ cb_Backend_search_index_drop(VALUE self, VALUE index_name, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(index_name, T_STRING);
     VALUE exc = Qnil;
     do {
         couchbase::operations::search_index_drop_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
         auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_drop_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::search_index_drop_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::search_index_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.error.empty()) {
@@ -4286,18 +5185,22 @@ cb_Backend_search_index_get_documents_count(VALUE self, VALUE index_name, VALUE
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(index_name, T_STRING);
     VALUE exc = Qnil;
     do {
         couchbase::operations::search_index_get_documents_count_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
         auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_get_documents_count_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::search_index_get_documents_count_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::search_index_get_documents_count_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.error.empty()) {
@@ -4327,18 +5230,22 @@ cb_Backend_search_index_get_stats(VALUE self, VALUE index_name, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(index_name, T_STRING);
     VALUE exc = Qnil;
     do {
         couchbase::operations::search_index_get_stats_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
         auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_get_stats_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::search_index_get_stats_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::search_index_get_stats_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.error.empty()) {
@@ -4363,16 +5270,20 @@ cb_Backend_search_get_stats(VALUE self, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::search_index_stats_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_stats_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::search_index_stats_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::search_index_stats_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(resp.ec, "unable to get stats for the search service");
@@ -4392,19 +5303,23 @@ cb_Backend_search_index_pause_ingest(VALUE self, VALUE index_name, VALUE timeout
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(index_name, T_STRING);
     VALUE exc = Qnil;
     do {
         couchbase::operations::search_index_control_ingest_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
         req.pause = true;
         auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_control_ingest_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::search_index_control_ingest_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::search_index_control_ingest_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.error.empty()) {
@@ -4431,19 +5346,23 @@ cb_Backend_search_index_resume_ingest(VALUE self, VALUE index_name, VALUE timeou
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(index_name, T_STRING);
     VALUE exc = Qnil;
     do {
         couchbase::operations::search_index_control_ingest_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
         req.pause = false;
         auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_control_ingest_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::search_index_control_ingest_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::search_index_control_ingest_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.error.empty()) {
@@ -4470,19 +5389,23 @@ cb_Backend_search_index_allow_querying(VALUE self, VALUE index_name, VALUE timeo
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(index_name, T_STRING);
     VALUE exc = Qnil;
     do {
         couchbase::operations::search_index_control_query_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
         req.allow = true;
         auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_control_query_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::search_index_control_query_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::search_index_control_query_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.error.empty()) {
@@ -4509,19 +5432,23 @@ cb_Backend_search_index_disallow_querying(VALUE self, VALUE index_name, VALUE ti
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(index_name, T_STRING);
     VALUE exc = Qnil;
     do {
         couchbase::operations::search_index_control_query_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
         req.allow = false;
         auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_control_query_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::search_index_control_query_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::search_index_control_query_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.error.empty()) {
@@ -4548,19 +5475,23 @@ cb_Backend_search_index_freeze_plan(VALUE self, VALUE index_name, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(index_name, T_STRING);
     VALUE exc = Qnil;
     do {
         couchbase::operations::search_index_control_plan_freeze_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
         req.freeze = true;
         auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_control_plan_freeze_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::search_index_control_plan_freeze_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::search_index_control_plan_freeze_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.error.empty()) {
@@ -4587,19 +5518,23 @@ cb_Backend_search_index_unfreeze_plan(VALUE self, VALUE index_name, VALUE timeou
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(index_name, T_STRING);
     VALUE exc = Qnil;
     do {
         couchbase::operations::search_index_control_plan_freeze_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
         req.freeze = false;
         auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_control_plan_freeze_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::search_index_control_plan_freeze_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::search_index_control_plan_freeze_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.error.empty()) {
@@ -4626,6 +5561,7 @@ cb_Backend_search_index_analyze_document(VALUE self, VALUE index_name, VALUE enc
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(index_name, T_STRING);
@@ -4633,7 +5569,10 @@ cb_Backend_search_index_analyze_document(VALUE self, VALUE index_name, VALUE enc
     VALUE exc = Qnil;
     do {
         couchbase::operations::search_index_analyze_document_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
 
         req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
         req.encoded_document.assign(RSTRING_PTR(encoded_document), static_cast<size_t>(RSTRING_LEN(encoded_document)));
@@ -4641,7 +5580,7 @@ cb_Backend_search_index_analyze_document(VALUE self, VALUE index_name, VALUE enc
         auto barrier = std::make_shared<std::promise<couchbase::operations::search_index_analyze_document_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::search_index_analyze_document_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::search_index_analyze_document_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.error.empty()) {
@@ -4669,6 +5608,7 @@ cb_Backend_document_search(VALUE self, VALUE index_name, VALUE query, VALUE opti
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(index_name, T_STRING);
@@ -4683,7 +5623,10 @@ cb_Backend_document_search(VALUE self, VALUE index_name, VALUE query, VALUE opti
             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)));
         }
-        cb__extract_timeout(req, rb_hash_aref(options, rb_id2sym(rb_intern("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.query = tao::json::from_string(std::string(RSTRING_PTR(query), static_cast<size_t>(RSTRING_LEN(query))));
 
@@ -4823,7 +5766,7 @@ cb_Backend_document_search(VALUE self, VALUE index_name, VALUE query, VALUE opti
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::search_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute_http(req, [barrier](couchbase::operations::search_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute_http(req, [barrier](couchbase::operations::search_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc =
@@ -4994,6 +5937,7 @@ cb_Backend_dns_srv(VALUE self, VALUE hostname, VALUE service)
         tls = true;
     } else {
         rb_raise(rb_eArgError, "Unsupported service type: %+" PRIsVALUE, service);
+        return Qnil;
     }
     VALUE exc = Qnil;
     do {
@@ -5007,8 +5951,9 @@ cb_Backend_dns_srv(VALUE self, VALUE hostname, VALUE service)
         }
         auto barrier = std::make_shared<std::promise<couchbase::io::dns::dns_client::dns_srv_response>>();
         auto f = barrier->get_future();
-        client.query_srv(
-          host_name, service_name, [barrier](couchbase::io::dns::dns_client::dns_srv_response resp) mutable { barrier->set_value(resp); });
+        client.query_srv(host_name, service_name, [barrier](couchbase::io::dns::dns_client::dns_srv_response&& resp) mutable {
+            barrier->set_value(resp);
+        });
         ctx.run();
         auto resp = f.get();
         if (resp.ec) {
@@ -5038,16 +5983,20 @@ cb_Backend_analytics_get_pending_mutations(VALUE self, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_get_pending_mutations_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_get_pending_mutations_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::analytics_get_pending_mutations_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::analytics_get_pending_mutations_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.errors.empty()) {
@@ -5078,16 +6027,20 @@ cb_Backend_analytics_dataset_get_all(VALUE self, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_dataset_get_all_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_dataset_get_all_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::analytics_dataset_get_all_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::analytics_dataset_get_all_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.errors.empty()) {
@@ -5126,6 +6079,7 @@ cb_Backend_analytics_dataset_drop(VALUE self, VALUE dataset_name, VALUE datavers
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(dataset_name, T_STRING);
@@ -5136,7 +6090,10 @@ cb_Backend_analytics_dataset_drop(VALUE self, VALUE dataset_name, VALUE datavers
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_dataset_drop_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         req.dataset_name.assign(RSTRING_PTR(dataset_name), static_cast<size_t>(RSTRING_LEN(dataset_name)));
         if (!NIL_P(dataverse_name)) {
             req.dataverse_name.assign(RSTRING_PTR(dataverse_name), static_cast<size_t>(RSTRING_LEN(dataverse_name)));
@@ -5147,7 +6104,7 @@ cb_Backend_analytics_dataset_drop(VALUE self, VALUE dataset_name, VALUE datavers
         auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_dataset_drop_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::analytics_dataset_drop_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::analytics_dataset_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.errors.empty()) {
@@ -5183,6 +6140,7 @@ cb_Backend_analytics_dataset_create(VALUE self,
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(dataset_name, T_STRING);
@@ -5197,7 +6155,10 @@ cb_Backend_analytics_dataset_create(VALUE self,
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_dataset_create_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        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)));
         if (!NIL_P(condition)) {
@@ -5212,7 +6173,7 @@ cb_Backend_analytics_dataset_create(VALUE self,
         auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_dataset_create_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::analytics_dataset_create_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::analytics_dataset_create_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.errors.empty()) {
@@ -5242,6 +6203,7 @@ cb_Backend_analytics_dataverse_drop(VALUE self, VALUE dataverse_name, VALUE igno
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(dataverse_name, T_STRING);
@@ -5249,7 +6211,10 @@ cb_Backend_analytics_dataverse_drop(VALUE self, VALUE dataverse_name, VALUE igno
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_dataverse_drop_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         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);
@@ -5257,7 +6222,7 @@ cb_Backend_analytics_dataverse_drop(VALUE self, VALUE dataverse_name, VALUE igno
         auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_dataverse_drop_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::analytics_dataverse_drop_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::analytics_dataverse_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.errors.empty()) {
@@ -5284,6 +6249,7 @@ cb_Backend_analytics_dataverse_create(VALUE self, VALUE dataverse_name, VALUE ig
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(dataverse_name, T_STRING);
@@ -5294,7 +6260,10 @@ cb_Backend_analytics_dataverse_create(VALUE self, VALUE dataverse_name, VALUE ig
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_dataverse_create_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         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);
@@ -5302,7 +6271,7 @@ cb_Backend_analytics_dataverse_create(VALUE self, VALUE dataverse_name, VALUE ig
         auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_dataverse_create_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::analytics_dataverse_create_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::analytics_dataverse_create_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.errors.empty()) {
@@ -5329,16 +6298,20 @@ cb_Backend_analytics_index_get_all(VALUE self, VALUE timeout)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_index_get_all_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_index_get_all_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::analytics_index_get_all_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::analytics_index_get_all_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.errors.empty()) {
@@ -5382,6 +6355,7 @@ cb_Backend_analytics_index_create(VALUE self,
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(index_name, T_STRING);
@@ -5394,7 +6368,10 @@ cb_Backend_analytics_index_create(VALUE self,
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_index_create_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        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)));
         auto fields_num = static_cast<size_t>(RARRAY_LEN(fields));
@@ -5417,7 +6394,7 @@ cb_Backend_analytics_index_create(VALUE self,
         auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_index_create_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::analytics_index_create_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::analytics_index_create_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.errors.empty()) {
@@ -5454,6 +6431,7 @@ cb_Backend_analytics_index_drop(VALUE self,
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(index_name, T_STRING);
@@ -5465,7 +6443,10 @@ cb_Backend_analytics_index_drop(VALUE self,
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_index_drop_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        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)));
         if (!NIL_P(dataverse_name)) {
@@ -5477,7 +6458,7 @@ cb_Backend_analytics_index_drop(VALUE self,
         auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_index_drop_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::analytics_index_drop_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::analytics_index_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.errors.empty()) {
@@ -5509,6 +6490,7 @@ cb_Backend_analytics_link_connect(VALUE self, VALUE link_name, VALUE force, VALU
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(link_name, T_STRING);
@@ -5519,7 +6501,10 @@ cb_Backend_analytics_link_connect(VALUE self, VALUE link_name, VALUE force, VALU
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_link_connect_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        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)));
@@ -5530,7 +6515,7 @@ cb_Backend_analytics_link_connect(VALUE self, VALUE link_name, VALUE force, VALU
         auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_link_connect_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::analytics_link_connect_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::analytics_link_connect_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.errors.empty()) {
@@ -5560,6 +6545,7 @@ cb_Backend_analytics_link_disconnect(VALUE self, VALUE link_name, VALUE datavers
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(link_name, T_STRING);
@@ -5570,7 +6556,10 @@ cb_Backend_analytics_link_disconnect(VALUE self, VALUE link_name, VALUE datavers
     VALUE exc = Qnil;
     do {
         couchbase::operations::analytics_link_disconnect_request req{};
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        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)));
@@ -5578,7 +6567,7 @@ cb_Backend_analytics_link_disconnect(VALUE self, VALUE link_name, VALUE datavers
         auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_link_disconnect_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::analytics_link_disconnect_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::analytics_link_disconnect_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.errors.empty()) {
@@ -5620,6 +6609,7 @@ cb_Backend_document_analytics(VALUE self, VALUE statement, VALUE options)
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(statement, T_STRING);
@@ -5634,7 +6624,10 @@ cb_Backend_document_analytics(VALUE self, VALUE statement, VALUE options)
             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)));
         }
-        cb__extract_timeout(req, rb_hash_aref(options, rb_id2sym(rb_intern("timeout"))));
+        exc = cb__extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
         VALUE readonly = rb_hash_aref(options, rb_id2sym(rb_intern("readonly")));
         if (!NIL_P(readonly)) {
             req.readonly = RTEST(readonly);
@@ -5680,7 +6673,7 @@ cb_Backend_document_analytics(VALUE self, VALUE statement, VALUE options)
         auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(req,
-                                       [barrier](couchbase::operations::analytics_response resp) mutable { barrier->set_value(resp); });
+                                       [barrier](couchbase::operations::analytics_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.payload.meta_data.errors && !resp.payload.meta_data.errors->empty()) {
@@ -5845,6 +6838,7 @@ cb_Backend_view_index_get_all(VALUE self, VALUE bucket_name, VALUE name_space, V
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -5858,6 +6852,7 @@ cb_Backend_view_index_get_all(VALUE self, VALUE bucket_name, VALUE name_space, V
         ns = couchbase::operations::design_document::name_space::production;
     } else {
         rb_raise(rb_eArgError, "Unknown design document namespace: %+" PRIsVALUE, type);
+        return Qnil;
     }
 
     VALUE exc = Qnil;
@@ -5865,11 +6860,14 @@ cb_Backend_view_index_get_all(VALUE self, VALUE bucket_name, VALUE name_space, V
         couchbase::operations::view_index_get_all_request req{};
         req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
         req.name_space = ns;
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         auto barrier = std::make_shared<std::promise<couchbase::operations::view_index_get_all_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::view_index_get_all_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::view_index_get_all_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(resp.ec, "unable to get list of the design documents");
@@ -5922,6 +6920,7 @@ cb_Backend_view_index_get(VALUE self, VALUE bucket_name, VALUE document_name, VA
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -5936,6 +6935,7 @@ cb_Backend_view_index_get(VALUE self, VALUE bucket_name, VALUE document_name, VA
         ns = couchbase::operations::design_document::name_space::production;
     } else {
         rb_raise(rb_eArgError, "Unknown design document namespace: %+" PRIsVALUE, type);
+        return Qnil;
     }
 
     VALUE exc = Qnil;
@@ -5944,11 +6944,14 @@ cb_Backend_view_index_get(VALUE self, VALUE bucket_name, VALUE document_name, VA
         req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
         req.document_name.assign(RSTRING_PTR(document_name), static_cast<size_t>(RSTRING_LEN(document_name)));
         req.name_space = ns;
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         auto barrier = std::make_shared<std::promise<couchbase::operations::view_index_get_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::view_index_get_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::view_index_get_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(
@@ -6000,6 +7003,7 @@ cb_Backend_view_index_drop(VALUE self, VALUE bucket_name, VALUE document_name, V
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -6014,6 +7018,7 @@ cb_Backend_view_index_drop(VALUE self, VALUE bucket_name, VALUE document_name, V
         ns = couchbase::operations::design_document::name_space::production;
     } else {
         rb_raise(rb_eArgError, "Unknown design document namespace: %+" PRIsVALUE, type);
+        return Qnil;
     }
 
     VALUE exc = Qnil;
@@ -6022,11 +7027,14 @@ cb_Backend_view_index_drop(VALUE self, VALUE bucket_name, VALUE document_name, V
         req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
         req.document_name.assign(RSTRING_PTR(document_name), static_cast<size_t>(RSTRING_LEN(document_name)));
         req.name_space = ns;
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         auto barrier = std::make_shared<std::promise<couchbase::operations::view_index_drop_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::view_index_drop_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::view_index_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(
@@ -6049,6 +7057,7 @@ cb_Backend_view_index_upsert(VALUE self, VALUE bucket_name, VALUE document, VALU
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -6063,6 +7072,7 @@ cb_Backend_view_index_upsert(VALUE self, VALUE bucket_name, VALUE document, VALU
         ns = couchbase::operations::design_document::name_space::production;
     } else {
         rb_raise(rb_eArgError, "Unknown design document namespace: %+" PRIsVALUE, type);
+        return Qnil;
     }
 
     VALUE exc = Qnil;
@@ -6098,11 +7108,14 @@ cb_Backend_view_index_upsert(VALUE self, VALUE bucket_name, VALUE document, VALU
             }
         }
 
-        cb__extract_timeout(req, timeout);
+        exc = cb__extract_timeout(req, timeout);
+        if (!NIL_P(exc)) {
+            break;
+        }
         auto barrier = std::make_shared<std::promise<couchbase::operations::view_index_upsert_response>>();
         auto f = barrier->get_future();
         backend->cluster->execute_http(
-          req, [barrier](couchbase::operations::view_index_upsert_response resp) mutable { barrier->set_value(resp); });
+          req, [barrier](couchbase::operations::view_index_upsert_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             exc = cb__map_error_code(
@@ -6125,6 +7138,7 @@ cb_Backend_document_view(VALUE self, VALUE bucket_name, VALUE design_document_na
 
     if (!backend->cluster) {
         rb_raise(rb_eArgError, "Cluster has been closed already");
+        return Qnil;
     }
 
     Check_Type(bucket_name, T_STRING);
@@ -6139,6 +7153,7 @@ cb_Backend_document_view(VALUE self, VALUE bucket_name, VALUE design_document_na
         ns = couchbase::operations::design_document::name_space::production;
     } else {
         rb_raise(rb_eArgError, "Unknown design document namespace: %+" PRIsVALUE, type);
+        return Qnil;
     }
     if (!NIL_P(options)) {
         Check_Type(options, T_HASH);
@@ -6151,8 +7166,11 @@ cb_Backend_document_view(VALUE self, VALUE bucket_name, VALUE design_document_na
         req.document_name.assign(RSTRING_PTR(design_document_name), static_cast<size_t>(RSTRING_LEN(design_document_name)));
         req.view_name.assign(RSTRING_PTR(view_name), static_cast<size_t>(RSTRING_LEN(view_name)));
         req.name_space = ns;
+        exc = cb__extract_timeout(req, options);
+        if (!NIL_P(exc)) {
+            break;
+        }
         if (!NIL_P(options)) {
-            cb__extract_timeout(req, rb_hash_aref(options, rb_id2sym(rb_intern("timeout"))));
             VALUE debug = rb_hash_aref(options, rb_id2sym(rb_intern("debug")));
             if (!NIL_P(debug)) {
                 req.debug = RTEST(debug);
@@ -6246,8 +7264,8 @@ cb_Backend_document_view(VALUE self, VALUE bucket_name, VALUE design_document_na
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::document_view_response>>();
         auto f = barrier->get_future();
-        backend->cluster->execute_http(req,
-                                       [barrier](couchbase::operations::document_view_response resp) mutable { barrier->set_value(resp); });
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::document_view_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
         if (resp.ec) {
             if (resp.error) {
@@ -6301,6 +7319,116 @@ cb_Backend_document_view(VALUE self, VALUE bucket_name, VALUE design_document_na
     return Qnil;
 }
 
+static VALUE
+cb_Backend_set_log_level(VALUE self, VALUE log_level)
+{
+    (void)self;
+    Check_Type(log_level, T_SYMBOL);
+    ID type = rb_sym2id(log_level);
+    if (type == rb_intern("trace")) {
+        spdlog::set_level(spdlog::level::trace);
+    } else if (type == rb_intern("debug")) {
+        spdlog::set_level(spdlog::level::debug);
+    } else if (type == rb_intern("info")) {
+        spdlog::set_level(spdlog::level::info);
+    } else if (type == rb_intern("warn")) {
+        spdlog::set_level(spdlog::level::warn);
+    } else if (type == rb_intern("error")) {
+        spdlog::set_level(spdlog::level::err);
+    } else if (type == rb_intern("critical")) {
+        spdlog::set_level(spdlog::level::critical);
+    } else if (type == rb_intern("off")) {
+        spdlog::set_level(spdlog::level::off);
+    } else {
+        rb_raise(rb_eArgError, "Unsupported log level type: %+" PRIsVALUE, log_level);
+        return Qnil;
+    }
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_get_log_level(VALUE self)
+{
+    (void)self;
+    switch (spdlog::get_level()) {
+        case spdlog::level::trace:
+            return rb_id2sym(rb_intern("trace"));
+        case spdlog::level::debug:
+            return rb_id2sym(rb_intern("debug"));
+        case spdlog::level::info:
+            return rb_id2sym(rb_intern("info"));
+        case spdlog::level::warn:
+            return rb_id2sym(rb_intern("warn"));
+        case spdlog::level::err:
+            return rb_id2sym(rb_intern("error"));
+        case spdlog::level::critical:
+            return rb_id2sym(rb_intern("critical"));
+        case spdlog::level::off:
+            return rb_id2sym(rb_intern("off"));
+        case spdlog::level::n_levels:
+            return Qnil;
+    }
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_snappy_compress(VALUE self, VALUE data)
+{
+    (void)self;
+    Check_Type(data, T_STRING);
+
+    std::string compressed{};
+    std::size_t compressed_size = snappy::Compress(RSTRING_PTR(data), static_cast<std::size_t>(RSTRING_LEN(data)), &compressed);
+    return rb_str_new(compressed.data(), static_cast<long>(compressed_size));
+}
+
+static VALUE
+cb_Backend_snappy_uncompress(VALUE self, VALUE data)
+{
+    (void)self;
+    Check_Type(data, T_STRING);
+
+    std::string uncompressed{};
+    bool success = snappy::Uncompress(RSTRING_PTR(data), static_cast<std::size_t>(RSTRING_LEN(data)), &uncompressed);
+    if (success) {
+        return rb_str_new(uncompressed.data(), static_cast<long>(uncompressed.size()));
+    }
+    rb_raise(rb_eArgError, "Unable to decompress buffer");
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_leb128_encode(VALUE self, VALUE number)
+{
+    (void)self;
+    switch (TYPE(number)) {
+        case T_FIXNUM:
+        case T_BIGNUM:
+            break;
+        default:
+            rb_raise(rb_eArgError, "The value must be a number");
+    }
+    couchbase::protocol::unsigned_leb128<std::uint64_t> encoded(NUM2ULL(number));
+    std::string buf = encoded.get();
+    return rb_str_new(buf.data(), static_cast<long>(buf.size()));
+}
+
+static VALUE
+cb_Backend_leb128_decode(VALUE self, VALUE data)
+{
+    (void)self;
+    Check_Type(data, T_STRING);
+    std::string buf(RSTRING_PTR(data), static_cast<std::size_t>(RSTRING_LEN(data)));
+    if (!buf.empty()) {
+        auto rv = couchbase::protocol::decode_unsigned_leb128<std::uint64_t>(buf, couchbase::protocol::Leb128NoThrow());
+        if (rv.second.data()) {
+            return ULL2NUM(rv.first);
+        }
+    }
+    rb_raise(rb_eArgError, "Unable to decode the buffer");
+    return Qnil;
+}
+
 static void
 init_backend(VALUE mCouchbase)
 {
@@ -6310,23 +7438,29 @@ init_backend(VALUE mCouchbase)
     rb_define_method(cBackend, "close", VALUE_FUNC(cb_Backend_close), 0);
     rb_define_method(cBackend, "open_bucket", VALUE_FUNC(cb_Backend_open_bucket), 2);
     rb_define_method(cBackend, "diagnostics", VALUE_FUNC(cb_Backend_diagnostics), 1);
+    rb_define_method(cBackend, "ping", VALUE_FUNC(cb_Backend_ping), 2);
 
     rb_define_method(cBackend, "document_get", VALUE_FUNC(cb_Backend_document_get), 4);
-    rb_define_method(cBackend, "document_get_projected", VALUE_FUNC(cb_Backend_document_get_projected), 7);
+    rb_define_method(cBackend, "document_get_multi", VALUE_FUNC(cb_Backend_document_get_multi), 2);
+    rb_define_method(cBackend, "document_get_projected", VALUE_FUNC(cb_Backend_document_get_projected), 4);
     rb_define_method(cBackend, "document_get_and_lock", VALUE_FUNC(cb_Backend_document_get_and_lock), 5);
     rb_define_method(cBackend, "document_get_and_touch", VALUE_FUNC(cb_Backend_document_get_and_touch), 5);
-    rb_define_method(cBackend, "document_insert", VALUE_FUNC(cb_Backend_document_insert), 7);
-    rb_define_method(cBackend, "document_replace", VALUE_FUNC(cb_Backend_document_replace), 7);
-    rb_define_method(cBackend, "document_upsert", VALUE_FUNC(cb_Backend_document_upsert), 7);
-    rb_define_method(cBackend, "document_remove", VALUE_FUNC(cb_Backend_document_remove), 5);
-    rb_define_method(cBackend, "document_lookup_in", VALUE_FUNC(cb_Backend_document_lookup_in), 6);
-    rb_define_method(cBackend, "document_mutate_in", VALUE_FUNC(cb_Backend_document_mutate_in), 6);
+    rb_define_method(cBackend, "document_insert", VALUE_FUNC(cb_Backend_document_insert), 6);
+    rb_define_method(cBackend, "document_replace", VALUE_FUNC(cb_Backend_document_replace), 6);
+    rb_define_method(cBackend, "document_upsert", VALUE_FUNC(cb_Backend_document_upsert), 6);
+    rb_define_method(cBackend, "document_upsert_multi", VALUE_FUNC(cb_Backend_document_upsert_multi), 2);
+    rb_define_method(cBackend, "document_append", VALUE_FUNC(cb_Backend_document_append), 5);
+    rb_define_method(cBackend, "document_prepend", VALUE_FUNC(cb_Backend_document_prepend), 5);
+    rb_define_method(cBackend, "document_remove", VALUE_FUNC(cb_Backend_document_remove), 4);
+    rb_define_method(cBackend, "document_remove_multi", VALUE_FUNC(cb_Backend_document_remove_multi), 2);
+    rb_define_method(cBackend, "document_lookup_in", VALUE_FUNC(cb_Backend_document_lookup_in), 5);
+    rb_define_method(cBackend, "document_mutate_in", VALUE_FUNC(cb_Backend_document_mutate_in), 5);
     rb_define_method(cBackend, "document_query", VALUE_FUNC(cb_Backend_document_query), 2);
     rb_define_method(cBackend, "document_touch", VALUE_FUNC(cb_Backend_document_touch), 5);
     rb_define_method(cBackend, "document_exists", VALUE_FUNC(cb_Backend_document_exists), 4);
     rb_define_method(cBackend, "document_unlock", VALUE_FUNC(cb_Backend_document_unlock), 5);
-    rb_define_method(cBackend, "document_increment", VALUE_FUNC(cb_Backend_document_increment), 5);
-    rb_define_method(cBackend, "document_decrement", VALUE_FUNC(cb_Backend_document_decrement), 5);
+    rb_define_method(cBackend, "document_increment", VALUE_FUNC(cb_Backend_document_increment), 4);
+    rb_define_method(cBackend, "document_decrement", VALUE_FUNC(cb_Backend_document_decrement), 4);
     rb_define_method(cBackend, "document_search", VALUE_FUNC(cb_Backend_document_search), 3);
     rb_define_method(cBackend, "document_analytics", VALUE_FUNC(cb_Backend_document_analytics), 2);
     rb_define_method(cBackend, "document_view", VALUE_FUNC(cb_Backend_document_view), 5);
@@ -6400,6 +7534,12 @@ init_backend(VALUE mCouchbase)
     rb_define_method(cBackend, "collections_manifest_get", VALUE_FUNC(cb_Backend_collections_manifest_get), 2);
     rb_define_singleton_method(cBackend, "dns_srv", VALUE_FUNC(cb_Backend_dns_srv), 2);
     rb_define_singleton_method(cBackend, "parse_connection_string", VALUE_FUNC(cb_Backend_parse_connection_string), 1);
+    rb_define_singleton_method(cBackend, "set_log_level", VALUE_FUNC(cb_Backend_set_log_level), 1);
+    rb_define_singleton_method(cBackend, "get_log_level", VALUE_FUNC(cb_Backend_get_log_level), 0);
+    rb_define_singleton_method(cBackend, "snappy_compress", VALUE_FUNC(cb_Backend_snappy_compress), 1);
+    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);
 }
 
 void