couchbase 3.0.2 → 3.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4674765d2d910949acdc81040062ecdcf6b5089297e33bbfc02c3c1cf705b60c
-  data.tar.gz: d24c030c9b3a6620d8b7740af911a5b8640f6d98b857719e50df7981a4be46ce
+  metadata.gz: 850654b24f508816010fe6558dc0b5e50bd6a4a54667c17d929988762ea836c6
+  data.tar.gz: 4e6f334a34c80ec64fa15a8fbf16f22a913bded0e10aed76e5870db6ded5a17b
 SHA512:
-  metadata.gz: 97e0ea2efa94117e1e3738951c86cd1d3176a5304de3e70221916fa3245c96d5d932e10558eb254e06a3047e2adaa3cc97c8e77290876d7422a3d62ecec91fe6
-  data.tar.gz: dd31e90a9bf872e1edcc03eab14796122bb201e84a42d7bb68d8630bed55612deb01ebc363465209316d5d2030e210bf404035491f60e259d216240937216b7b
+  metadata.gz: d1e7b161fe8fbca8d8ca8d524014f6be1eb0fd7dffb3295f18ee6aa2b20997c2ff0277b90011a3330892e3173038b0667e73e791b945ee7490bda7a9abebe52d
+  data.tar.gz: b72cb74eb7f1a34fd0ed0421af78d1a322f2dde47f615466cf9aaf80e3a5f7f4420110650b400a515f4b0f4ada98c388b00b0feff5b416e1216e59c58299500f

data/README.md

@@ -20,12 +20,12 @@ Please attach version information to ticket/post. To obtain this information use
 
 ## Installation
 
-The library tested with the MRI 2.5, 2.6 and 2.7. Supported platforms are Linux and MacOS.
+The library tested with the MRI 2.5, 2.6, 2.7 and 3.0. Supported platforms are Linux and MacOS.
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "couchbase", "3.0.2"
+gem "couchbase", "3.0.3"
 ```
 
 And then execute:

data/ext/CMakeLists.txt

@@ -6,6 +6,9 @@ include(cmake/StandardProjectSettings.cmake)
 # 'library' to set the c++ standard / compile-time options requested
 add_library(project_options INTERFACE)
 target_compile_features(project_options INTERFACE cxx_std_17)
+if(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
+  target_compile_options(project_options INTERFACE -fdeclspec)
+endif()
 
 # 'library' to use the warnings specified in CompilerWarnings.cmake
 add_library(project_warnings INTERFACE)

data/ext/build_version.hxx.in

@@ -26,5 +26,5 @@ constexpr auto BACKEND_CXX_COMPILER = "@CMAKE_CXX_COMPILER_ID@ @CMAKE_CXX_COMPIL
 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";
+constexpr auto BACKEND_GIT_REVISION = "bcb5da39fd4dfd3bd7ce917abc89faf1fbcd7d5f";
 } // namespace couchbase

data/ext/cmake/CompilerWarnings.cmake

@@ -66,6 +66,7 @@ function(set_project_warnings project_name)
       -Wduplicated-branches # warn if if / else branches have duplicated code
       -Wlogical-op # warn about logical operations being used where bitwise were probably wanted
       -Wuseless-cast # warn if you perform a cast to the same type
+      -Wdeprecated-declarations # warn if [[deprecated]] elements being used
   )
 
   if(MSVC)

data/ext/cmake/PreventInSourceBuilds.cmake

@@ -5,6 +5,9 @@ function(AssureOutOfSourceBuilds)
   get_filename_component(srcdir "${CMAKE_SOURCE_DIR}" REALPATH)
   get_filename_component(bindir "${CMAKE_BINARY_DIR}" REALPATH)
 
+  message(STATUS "CMAKE_SOURCE_DIR=${srcdir}")
+  message(STATUS "CMAKE_BINARY_DIR=${bindir}")
+
   # disallow in-source builds
   if("${srcdir}" STREQUAL "${bindir}")
     message("######################################################")
@@ -15,4 +18,4 @@ function(AssureOutOfSourceBuilds)
   endif()
 endfunction()
 
-assureoutofsourcebuilds()
+AssureOutOfSourceBuilds()

data/ext/couchbase/bucket.hxx

@@ -242,7 +242,28 @@ class bucket : public std::enable_shared_from_this<bucket>
         auto cmd = std::make_shared<operations::mcbp_command<bucket, Request>>(ctx_, shared_from_this(), request);
         cmd->start([cmd, handler = std::forward<Handler>(handler)](std::error_code ec, std::optional<io::mcbp_message> msg) mutable {
             using encoded_response_type = typename Request::encoded_response_type;
-            handler(make_response(ec, cmd->request, msg ? encoded_response_type(*msg) : encoded_response_type{}));
+            auto resp = msg ? encoded_response_type(*msg) : encoded_response_type{};
+            error_context::key_value ctx{};
+            ctx.id = cmd->request.id;
+            ctx.opaque = resp.opaque();
+            ctx.ec = ec;
+            if (ctx.ec && ctx.opaque == 0) {
+                ctx.opaque = cmd->request.opaque;
+            }
+            if (msg) {
+                ctx.status_code = resp.status();
+            }
+            ctx.retry_attempts = cmd->request.retries.retry_attempts;
+            ctx.retry_reasons = cmd->request.retries.reasons;
+            if (cmd->session_) {
+                ctx.last_dispatched_from = cmd->session_->local_address();
+                ctx.last_dispatched_to = cmd->session_->remote_address();
+                if (msg) {
+                    ctx.error_map_info = cmd->session_->decode_error_code(msg->header.status());
+                }
+            }
+            ctx.enhanced_error_info = resp.error_info();
+            handler(make_response(std::move(ctx), cmd->request, std::move(resp)));
         });
         if (config_) {
             map_and_send(cmd);
@@ -287,7 +308,12 @@ class bucket : public std::enable_shared_from_this<bucket>
                   cmd->manager_, cmd, io::retry_reason::node_not_available, std::make_error_code(error::common_errc::request_canceled));
             }
         }
-        cmd->send_to(sessions_.at(static_cast<std::size_t>(index)));
+        auto session = sessions_.at(static_cast<std::size_t>(index));
+        if (session->is_stopped()) {
+            return io::retry_orchestrator::maybe_retry(
+              cmd->manager_, cmd, io::retry_reason::node_not_available, std::make_error_code(error::common_errc::request_canceled));
+        }
+        cmd->send_to(session);
     }
 
     template<typename Request>

data/ext/couchbase/cluster.hxx

@@ -151,7 +151,11 @@ class cluster
     {
         auto bucket = buckets_.find(request.id.bucket);
         if (bucket == buckets_.end()) {
-            return handler(operations::make_response(std::make_error_code(error::common_errc::bucket_not_found), request, {}));
+            error_context::key_value ctx{};
+            ctx.id = request.id;
+            ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
+            using response_type = typename Request::encoded_response_type;
+            return handler(operations::make_response(std::move(ctx), request, response_type{}));
         }
         return bucket->second->execute(request, std::forward<Handler>(handler));
     }
@@ -161,7 +165,9 @@ class cluster
     {
         auto session = session_manager_->check_out(Request::type, origin_.credentials());
         if (!session) {
-            return handler(operations::make_response(std::make_error_code(error::common_errc::service_not_available), request, {}));
+            typename Request::error_context_type ctx{};
+            ctx.ec = std::make_error_code(error::common_errc::service_not_available);
+            return handler(operations::make_response(std::move(ctx), request, {}));
         }
         auto cmd = std::make_shared<operations::http_command<Request>>(ctx_, request);
         cmd->send_to(session, [this, session, handler = std::forward<Handler>(handler)](typename Request::response_type resp) mutable {

data/ext/couchbase/couchbase.cxx

@@ -18,8 +18,8 @@
 #include <build_info.hxx>
 #include <version.hxx>
 
+#include <asio.hpp>
 #include <openssl/crypto.h>
-#include <asio/version.hpp>
 
 #include <spdlog/spdlog.h>
 #include <spdlog/cfg/env.h>
@@ -41,12 +41,12 @@
 #include <ruby/version.h>
 #endif
 
-#if !defined(RB_METHOD_DEFINITION_DECL)
-#define VALUE_FUNC(f) reinterpret_cast<VALUE (*)(ANYARGS)>(f)
-#define INT_FUNC(f) reinterpret_cast<int (*)(ANYARGS)>(f)
-#else
+#if defined(RB_METHOD_DEFINITION_DECL) || RUBY_API_VERSION_MAJOR == 3
 #define VALUE_FUNC(f) (f)
 #define INT_FUNC(f) (f)
+#else
+#define VALUE_FUNC(f) reinterpret_cast<VALUE (*)(ANYARGS)>(f)
+#define INT_FUNC(f) reinterpret_cast<int (*)(ANYARGS)>(f)
 #endif
 
 static void
@@ -63,7 +63,8 @@ init_versions(VALUE mCouchbase)
 
     std::string ver;
     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("backend")), rb_str_freeze(rb_external_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(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)));
@@ -72,16 +73,19 @@ init_versions(VALUE mCouchbase)
     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()))));
+    rb_hash_aset(cb_Version, rb_id2sym(rb_intern("ruby")), rb_str_freeze(rb_external_str_new(ver.c_str(), static_cast<long>(ver.size()))));
 #endif
     ver = fmt::format("{}.{}.{}", SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH);
-    rb_hash_aset(cb_Version, rb_id2sym(rb_intern("spdlog")), rb_str_freeze(rb_str_new(ver.c_str(), static_cast<long>(ver.size()))));
+    rb_hash_aset(
+      cb_Version, rb_id2sym(rb_intern("spdlog")), rb_str_freeze(rb_external_str_new(ver.c_str(), static_cast<long>(ver.size()))));
     ver = fmt::format("{}.{}.{}", VERSION_SPLIT_(ASIO_VERSION));
-    rb_hash_aset(cb_Version, rb_id2sym(rb_intern("asio")), rb_str_freeze(rb_str_new(ver.c_str(), static_cast<long>(ver.size()))));
+    rb_hash_aset(cb_Version, rb_id2sym(rb_intern("asio")), rb_str_freeze(rb_external_str_new(ver.c_str(), static_cast<long>(ver.size()))));
     ver = fmt::format("{}.{}.{}", SNAPPY_MAJOR, SNAPPY_MINOR, SNAPPY_PATCHLEVEL);
-    rb_hash_aset(cb_Version, rb_id2sym(rb_intern("snappy")), rb_str_freeze(rb_str_new(ver.c_str(), static_cast<long>(ver.size()))));
+    rb_hash_aset(
+      cb_Version, rb_id2sym(rb_intern("snappy")), rb_str_freeze(rb_external_str_new(ver.c_str(), static_cast<long>(ver.size()))));
     ver = fmt::format("{}.{}.{}", HTTP_PARSER_VERSION_MAJOR, HTTP_PARSER_VERSION_MINOR, HTTP_PARSER_VERSION_PATCH);
-    rb_hash_aset(cb_Version, rb_id2sym(rb_intern("http_parser")), rb_str_freeze(rb_str_new(ver.c_str(), static_cast<long>(ver.size()))));
+    rb_hash_aset(
+      cb_Version, rb_id2sym(rb_intern("http_parser")), rb_str_freeze(rb_external_str_new(ver.c_str(), static_cast<long>(ver.size()))));
     rb_hash_aset(cb_Version, rb_id2sym(rb_intern("openssl_headers")), rb_str_freeze(rb_str_new_cstr(OPENSSL_VERSION_TEXT)));
 #if defined(OPENSSL_VERSION)
     rb_hash_aset(cb_Version, rb_id2sym(rb_intern("openssl_runtime")), rb_str_freeze(rb_str_new_cstr(OpenSSL_version(OPENSSL_VERSION))));
@@ -584,6 +588,303 @@ cb__map_error_code(std::error_code ec, const std::string& message)
     return rb_exc_new_cstr(eBackendError, fmt::format("{}: {}", message, ec.message()).c_str());
 }
 
+static VALUE
+cb__map_error_code(const couchbase::error_context::key_value& ctx, const std::string& message)
+{
+    VALUE exc = cb__map_error_code(ctx.ec, message);
+    VALUE error_context = rb_hash_new();
+    std::string error(fmt::format("{}, {}", ctx.ec.value(), ctx.ec.message()));
+    rb_hash_aset(error_context, rb_id2sym(rb_intern("error")), rb_external_str_new(error.data(), static_cast<long>(error.size())));
+    rb_hash_aset(error_context, rb_id2sym(rb_intern("id")), rb_external_str_new(ctx.id.key.data(), static_cast<long>(ctx.id.key.size())));
+    rb_hash_aset(error_context,
+                 rb_id2sym(rb_intern("collection")),
+                 rb_external_str_new(ctx.id.collection.data(), static_cast<long>(ctx.id.collection.size())));
+    rb_hash_aset(
+      error_context, rb_id2sym(rb_intern("bucket")), rb_external_str_new(ctx.id.bucket.data(), static_cast<long>(ctx.id.bucket.size())));
+    rb_hash_aset(error_context, rb_id2sym(rb_intern("opaque")), ULONG2NUM(ctx.opaque));
+    if (ctx.status_code) {
+        std::string status(fmt::format("{}", ctx.status_code.value()));
+        rb_hash_aset(error_context, rb_id2sym(rb_intern("status")), rb_external_str_new(status.data(), static_cast<long>(status.size())));
+    }
+    if (ctx.error_map_info) {
+        VALUE error_map_info = rb_hash_new();
+        rb_hash_aset(error_map_info,
+                     rb_id2sym(rb_intern("name")),
+                     rb_external_str_new(ctx.error_map_info->name.data(), static_cast<long>(ctx.error_map_info->name.size())));
+        rb_hash_aset(
+          error_map_info,
+          rb_id2sym(rb_intern("desc")),
+          rb_external_str_new(ctx.error_map_info->description.data(), static_cast<long>(ctx.error_map_info->description.size())));
+        rb_hash_aset(error_context, rb_id2sym(rb_intern("error_map_info")), error_map_info);
+    }
+    if (ctx.enhanced_error_info) {
+        VALUE enhanced_error_info = rb_hash_new();
+        rb_hash_aset(
+          enhanced_error_info,
+          rb_id2sym(rb_intern("reference")),
+          rb_external_str_new(ctx.enhanced_error_info->reference.data(), static_cast<long>(ctx.enhanced_error_info->reference.size())));
+        rb_hash_aset(
+          enhanced_error_info,
+          rb_id2sym(rb_intern("context")),
+          rb_external_str_new(ctx.enhanced_error_info->context.data(), static_cast<long>(ctx.enhanced_error_info->context.size())));
+        rb_hash_aset(error_context, rb_id2sym(rb_intern("extended_error_info")), enhanced_error_info);
+    }
+    if (ctx.retry_attempts > 0) {
+        rb_hash_aset(error_context, rb_id2sym(rb_intern("retry_attempts")), INT2FIX(ctx.retry_attempts));
+        if (!ctx.retry_reasons.empty()) {
+            VALUE retry_reasons = rb_ary_new_capa(static_cast<long>(ctx.retry_reasons.size()));
+            for (const auto& reason : ctx.retry_reasons) {
+                auto reason_str = fmt::format("{}", reason);
+                rb_ary_push(retry_reasons, rb_id2sym(rb_intern(reason_str.c_str())));
+            }
+            rb_hash_aset(error_context, rb_id2sym(rb_intern("retry_reasons")), retry_reasons);
+        }
+    }
+    if (ctx.last_dispatched_to) {
+        rb_hash_aset(error_context,
+                     rb_id2sym(rb_intern("last_dispatched_to")),
+                     rb_external_str_new(ctx.last_dispatched_to->data(), static_cast<long>(ctx.last_dispatched_to->size())));
+    }
+    if (ctx.last_dispatched_from) {
+        rb_hash_aset(error_context,
+                     rb_id2sym(rb_intern("last_dispatched_from")),
+                     rb_external_str_new(ctx.last_dispatched_from->data(), static_cast<long>(ctx.last_dispatched_from->size())));
+    }
+    rb_iv_set(exc, "@context", error_context);
+    return exc;
+}
+
+static VALUE
+cb__map_error_code(const couchbase::error_context::query& ctx, const std::string& message)
+{
+    VALUE exc = cb__map_error_code(ctx.ec, message);
+    VALUE error_context = rb_hash_new();
+    std::string error(fmt::format("{}, {}", ctx.ec.value(), ctx.ec.message()));
+    rb_hash_aset(error_context, rb_id2sym(rb_intern("error")), rb_external_str_new(error.data(), static_cast<long>(error.size())));
+    rb_hash_aset(error_context,
+                 rb_id2sym(rb_intern("client_context_id")),
+                 rb_external_str_new(ctx.client_context_id.data(), static_cast<long>(ctx.client_context_id.size())));
+    rb_hash_aset(
+      error_context, rb_id2sym(rb_intern("statement")), rb_external_str_new(ctx.statement.data(), static_cast<long>(ctx.statement.size())));
+    if (ctx.parameters) {
+        rb_hash_aset(error_context,
+                     rb_id2sym(rb_intern("parameters")),
+                     rb_external_str_new(ctx.parameters->data(), static_cast<long>(ctx.parameters->size())));
+    }
+    rb_hash_aset(error_context, rb_id2sym(rb_intern("http_status")), INT2FIX(ctx.http_status));
+    rb_hash_aset(
+      error_context, rb_id2sym(rb_intern("http_body")), rb_external_str_new(ctx.http_body.data(), static_cast<long>(ctx.http_body.size())));
+    if (ctx.retry_attempts > 0) {
+        rb_hash_aset(error_context, rb_id2sym(rb_intern("retry_attempts")), INT2FIX(ctx.retry_attempts));
+        if (!ctx.retry_reasons.empty()) {
+            VALUE retry_reasons = rb_ary_new_capa(static_cast<long>(ctx.retry_reasons.size()));
+            for (const auto& reason : ctx.retry_reasons) {
+                auto reason_str = fmt::format("{}", reason);
+                rb_ary_push(retry_reasons, rb_id2sym(rb_intern(reason_str.c_str())));
+            }
+            rb_hash_aset(error_context, rb_id2sym(rb_intern("retry_reasons")), retry_reasons);
+        }
+    }
+    if (ctx.last_dispatched_to) {
+        rb_hash_aset(error_context,
+                     rb_id2sym(rb_intern("last_dispatched_to")),
+                     rb_external_str_new(ctx.last_dispatched_to->data(), static_cast<long>(ctx.last_dispatched_to->size())));
+    }
+    if (ctx.last_dispatched_from) {
+        rb_hash_aset(error_context,
+                     rb_id2sym(rb_intern("last_dispatched_from")),
+                     rb_external_str_new(ctx.last_dispatched_from->data(), static_cast<long>(ctx.last_dispatched_from->size())));
+    }
+    rb_iv_set(exc, "@context", error_context);
+    return exc;
+}
+
+static VALUE
+cb__map_error_code(const couchbase::error_context::analytics& ctx, const std::string& message)
+{
+    VALUE exc = cb__map_error_code(ctx.ec, message);
+    VALUE error_context = rb_hash_new();
+    std::string error(fmt::format("{}, {}", ctx.ec.value(), ctx.ec.message()));
+    rb_hash_aset(error_context, rb_id2sym(rb_intern("error")), rb_external_str_new(error.data(), static_cast<long>(error.size())));
+    rb_hash_aset(error_context,
+                 rb_id2sym(rb_intern("client_context_id")),
+                 rb_external_str_new(ctx.client_context_id.data(), static_cast<long>(ctx.client_context_id.size())));
+    rb_hash_aset(
+      error_context, rb_id2sym(rb_intern("statement")), rb_external_str_new(ctx.statement.data(), static_cast<long>(ctx.statement.size())));
+    if (ctx.parameters) {
+        rb_hash_aset(error_context,
+                     rb_id2sym(rb_intern("parameters")),
+                     rb_external_str_new(ctx.parameters->data(), static_cast<long>(ctx.parameters->size())));
+    }
+    rb_hash_aset(error_context, rb_id2sym(rb_intern("http_status")), INT2FIX(ctx.http_status));
+    rb_hash_aset(
+      error_context, rb_id2sym(rb_intern("http_body")), rb_external_str_new(ctx.http_body.data(), static_cast<long>(ctx.http_body.size())));
+    if (ctx.retry_attempts > 0) {
+        rb_hash_aset(error_context, rb_id2sym(rb_intern("retry_attempts")), INT2FIX(ctx.retry_attempts));
+        if (!ctx.retry_reasons.empty()) {
+            VALUE retry_reasons = rb_ary_new_capa(static_cast<long>(ctx.retry_reasons.size()));
+            for (const auto& reason : ctx.retry_reasons) {
+                auto reason_str = fmt::format("{}", reason);
+                rb_ary_push(retry_reasons, rb_id2sym(rb_intern(reason_str.c_str())));
+            }
+            rb_hash_aset(error_context, rb_id2sym(rb_intern("retry_reasons")), retry_reasons);
+        }
+    }
+    if (ctx.last_dispatched_to) {
+        rb_hash_aset(error_context,
+                     rb_id2sym(rb_intern("last_dispatched_to")),
+                     rb_external_str_new(ctx.last_dispatched_to->data(), static_cast<long>(ctx.last_dispatched_to->size())));
+    }
+    if (ctx.last_dispatched_from) {
+        rb_hash_aset(error_context,
+                     rb_id2sym(rb_intern("last_dispatched_from")),
+                     rb_external_str_new(ctx.last_dispatched_from->data(), static_cast<long>(ctx.last_dispatched_from->size())));
+    }
+    rb_iv_set(exc, "@context", error_context);
+    return exc;
+}
+
+static VALUE
+cb__map_error_code(const couchbase::error_context::view& ctx, const std::string& message)
+{
+    VALUE exc = cb__map_error_code(ctx.ec, message);
+    VALUE error_context = rb_hash_new();
+    std::string error(fmt::format("{}, {}", ctx.ec.value(), ctx.ec.message()));
+    rb_hash_aset(error_context, rb_id2sym(rb_intern("error")), rb_external_str_new(error.data(), static_cast<long>(error.size())));
+    rb_hash_aset(error_context,
+                 rb_id2sym(rb_intern("client_context_id")),
+                 rb_external_str_new(ctx.client_context_id.data(), static_cast<long>(ctx.client_context_id.size())));
+    rb_hash_aset(error_context,
+                 rb_id2sym(rb_intern("design_document_name")),
+                 rb_external_str_new(ctx.design_document_name.data(), static_cast<long>(ctx.design_document_name.size())));
+    rb_hash_aset(
+      error_context, rb_id2sym(rb_intern("view_name")), rb_external_str_new(ctx.view_name.data(), static_cast<long>(ctx.view_name.size())));
+    if (!ctx.query_string.empty()) {
+        VALUE parameters = rb_ary_new_capa(static_cast<long>(ctx.query_string.size()));
+        for (const auto& param : ctx.query_string) {
+            rb_ary_push(parameters, rb_external_str_new(param.data(), static_cast<long>(param.size())));
+        }
+        rb_hash_aset(error_context, rb_id2sym(rb_intern("parameters")), parameters);
+    }
+    rb_hash_aset(error_context, rb_id2sym(rb_intern("http_status")), INT2FIX(ctx.http_status));
+    rb_hash_aset(
+      error_context, rb_id2sym(rb_intern("http_body")), rb_external_str_new(ctx.http_body.data(), static_cast<long>(ctx.http_body.size())));
+    if (ctx.retry_attempts > 0) {
+        rb_hash_aset(error_context, rb_id2sym(rb_intern("retry_attempts")), INT2FIX(ctx.retry_attempts));
+        if (!ctx.retry_reasons.empty()) {
+            VALUE retry_reasons = rb_ary_new_capa(static_cast<long>(ctx.retry_reasons.size()));
+            for (const auto& reason : ctx.retry_reasons) {
+                auto reason_str = fmt::format("{}", reason);
+                rb_ary_push(retry_reasons, rb_id2sym(rb_intern(reason_str.c_str())));
+            }
+            rb_hash_aset(error_context, rb_id2sym(rb_intern("retry_reasons")), retry_reasons);
+        }
+    }
+    if (ctx.last_dispatched_to) {
+        rb_hash_aset(error_context,
+                     rb_id2sym(rb_intern("last_dispatched_to")),
+                     rb_external_str_new(ctx.last_dispatched_to->data(), static_cast<long>(ctx.last_dispatched_to->size())));
+    }
+    if (ctx.last_dispatched_from) {
+        rb_hash_aset(error_context,
+                     rb_id2sym(rb_intern("last_dispatched_from")),
+                     rb_external_str_new(ctx.last_dispatched_from->data(), static_cast<long>(ctx.last_dispatched_from->size())));
+    }
+    rb_iv_set(exc, "@context", error_context);
+    return exc;
+}
+
+static VALUE
+cb__map_error_code(const couchbase::error_context::http& ctx, const std::string& message)
+{
+    VALUE exc = cb__map_error_code(ctx.ec, message);
+    VALUE error_context = rb_hash_new();
+    std::string error(fmt::format("{}, {}", ctx.ec.value(), ctx.ec.message()));
+    rb_hash_aset(error_context, rb_id2sym(rb_intern("error")), rb_external_str_new(error.data(), static_cast<long>(error.size())));
+    rb_hash_aset(error_context,
+                 rb_id2sym(rb_intern("client_context_id")),
+                 rb_external_str_new(ctx.client_context_id.data(), static_cast<long>(ctx.client_context_id.size())));
+    rb_hash_aset(
+      error_context, rb_id2sym(rb_intern("method")), rb_external_str_new(ctx.method.data(), static_cast<long>(ctx.method.size())));
+    rb_hash_aset(error_context, rb_id2sym(rb_intern("path")), rb_external_str_new(ctx.path.data(), static_cast<long>(ctx.path.size())));
+    rb_hash_aset(error_context, rb_id2sym(rb_intern("http_status")), INT2FIX(ctx.http_status));
+    rb_hash_aset(
+      error_context, rb_id2sym(rb_intern("http_body")), rb_external_str_new(ctx.http_body.data(), static_cast<long>(ctx.http_body.size())));
+    if (ctx.retry_attempts > 0) {
+        rb_hash_aset(error_context, rb_id2sym(rb_intern("retry_attempts")), INT2FIX(ctx.retry_attempts));
+        if (!ctx.retry_reasons.empty()) {
+            VALUE retry_reasons = rb_ary_new_capa(static_cast<long>(ctx.retry_reasons.size()));
+            for (const auto& reason : ctx.retry_reasons) {
+                auto reason_str = fmt::format("{}", reason);
+                rb_ary_push(retry_reasons, rb_id2sym(rb_intern(reason_str.c_str())));
+            }
+            rb_hash_aset(error_context, rb_id2sym(rb_intern("retry_reasons")), retry_reasons);
+        }
+    }
+    if (ctx.last_dispatched_to) {
+        rb_hash_aset(error_context,
+                     rb_id2sym(rb_intern("last_dispatched_to")),
+                     rb_external_str_new(ctx.last_dispatched_to->data(), static_cast<long>(ctx.last_dispatched_to->size())));
+    }
+    if (ctx.last_dispatched_from) {
+        rb_hash_aset(error_context,
+                     rb_id2sym(rb_intern("last_dispatched_from")),
+                     rb_external_str_new(ctx.last_dispatched_from->data(), static_cast<long>(ctx.last_dispatched_from->size())));
+    }
+    rb_iv_set(exc, "@context", error_context);
+    return exc;
+}
+
+static VALUE
+cb__map_error_code(const couchbase::error_context::search& ctx, const std::string& message)
+{
+    VALUE exc = cb__map_error_code(ctx.ec, message);
+    VALUE error_context = rb_hash_new();
+    std::string error(fmt::format("{}, {}", ctx.ec.value(), ctx.ec.message()));
+    rb_hash_aset(error_context, rb_id2sym(rb_intern("error")), rb_external_str_new(error.data(), static_cast<long>(error.size())));
+    rb_hash_aset(error_context,
+                 rb_id2sym(rb_intern("client_context_id")),
+                 rb_external_str_new(ctx.client_context_id.data(), static_cast<long>(ctx.client_context_id.size())));
+    rb_hash_aset(error_context,
+                 rb_id2sym(rb_intern("index_name")),
+                 rb_external_str_new(ctx.index_name.data(), static_cast<long>(ctx.index_name.size())));
+    if (ctx.query) {
+        rb_hash_aset(
+          error_context, rb_id2sym(rb_intern("query")), rb_external_str_new(ctx.query->data(), static_cast<long>(ctx.query->size())));
+    }
+    if (ctx.parameters) {
+        rb_hash_aset(error_context,
+                     rb_id2sym(rb_intern("parameters")),
+                     rb_external_str_new(ctx.parameters->data(), static_cast<long>(ctx.parameters->size())));
+    }
+    rb_hash_aset(error_context, rb_id2sym(rb_intern("http_status")), INT2FIX(ctx.http_status));
+    rb_hash_aset(
+      error_context, rb_id2sym(rb_intern("http_body")), rb_external_str_new(ctx.http_body.data(), static_cast<long>(ctx.http_body.size())));
+    if (ctx.retry_attempts > 0) {
+        rb_hash_aset(error_context, rb_id2sym(rb_intern("retry_attempts")), INT2FIX(ctx.retry_attempts));
+        if (!ctx.retry_reasons.empty()) {
+            VALUE retry_reasons = rb_ary_new_capa(static_cast<long>(ctx.retry_reasons.size()));
+            for (const auto& reason : ctx.retry_reasons) {
+                auto reason_str = fmt::format("{}", reason);
+                rb_ary_push(retry_reasons, rb_id2sym(rb_intern(reason_str.c_str())));
+            }
+            rb_hash_aset(error_context, rb_id2sym(rb_intern("retry_reasons")), retry_reasons);
+        }
+    }
+    if (ctx.last_dispatched_to) {
+        rb_hash_aset(error_context,
+                     rb_id2sym(rb_intern("last_dispatched_to")),
+                     rb_external_str_new(ctx.last_dispatched_to->data(), static_cast<long>(ctx.last_dispatched_to->size())));
+    }
+    if (ctx.last_dispatched_from) {
+        rb_hash_aset(error_context,
+                     rb_id2sym(rb_intern("last_dispatched_from")),
+                     rb_external_str_new(ctx.last_dispatched_from->data(), static_cast<long>(ctx.last_dispatched_from->size())));
+    }
+    rb_iv_set(exc, "@context", error_context);
+    return exc;
+}
+
 static VALUE
 cb_Backend_open(VALUE self, VALUE connection_string, VALUE credentials, VALUE options)
 {
@@ -628,6 +929,24 @@ cb_Backend_open(VALUE self, VALUE connection_string, VALUE credentials, VALUE op
         if (NIL_P(certificate_path) || NIL_P(key_path)) {
             auth.username.assign(RSTRING_PTR(username), static_cast<size_t>(RSTRING_LEN(username)));
             auth.password.assign(RSTRING_PTR(password), static_cast<size_t>(RSTRING_LEN(password)));
+            VALUE allowed_mechanisms = rb_hash_aref(options, rb_id2sym(rb_intern("allowed_sasl_mechanisms")));
+            if (!NIL_P(allowed_mechanisms)) {
+                Check_Type(allowed_mechanisms, T_ARRAY);
+                auto allowed_mechanisms_size = static_cast<size_t>(RARRAY_LEN(allowed_mechanisms));
+                auth.allowed_sasl_mechanisms.reserve(allowed_mechanisms_size);
+                for (size_t i = 0; i < allowed_mechanisms_size; ++i) {
+                    VALUE mechanism = rb_ary_entry(allowed_mechanisms, static_cast<long>(i));
+                    if (mechanism == rb_id2sym(rb_intern("scram_sha512"))) {
+                        auth.allowed_sasl_mechanisms.emplace_back("SCRAM-SHA512");
+                    } else if (mechanism == rb_id2sym(rb_intern("scram_sha256"))) {
+                        auth.allowed_sasl_mechanisms.emplace_back("SCRAM-SHA256");
+                    } else if (mechanism == rb_id2sym(rb_intern("scram_sha1"))) {
+                        auth.allowed_sasl_mechanisms.emplace_back("SCRAM-SHA1");
+                    } else if (mechanism == rb_id2sym(rb_intern("plain"))) {
+                        auth.allowed_sasl_mechanisms.emplace_back("PLAIN");
+                    }
+                }
+            }
         } else {
             if (!connstr.tls) {
                 exc = rb_exc_new_cstr(
@@ -638,7 +957,7 @@ cb_Backend_open(VALUE self, VALUE connection_string, VALUE credentials, VALUE op
             auth.certificate_path.assign(RSTRING_PTR(certificate_path), static_cast<size_t>(RSTRING_LEN(certificate_path)));
             auth.key_path.assign(RSTRING_PTR(key_path), static_cast<size_t>(RSTRING_LEN(key_path)));
         }
-        couchbase::origin origin(auth, std::move(connstr));
+        couchbase::origin origin(auth, connstr);
         auto barrier = std::make_shared<std::promise<std::error_code>>();
         auto f = barrier->get_future();
         backend->cluster->open(origin, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
@@ -688,8 +1007,8 @@ cb_Backend_diagnostics(VALUE self, VALUE report_id)
         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("id")), rb_external_str_new(resp.id.data(), static_cast<long>(resp.id.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("sdk")), rb_external_str_new(resp.sdk.data(), static_cast<long>(resp.sdk.size())));
         rb_hash_aset(res, rb_id2sym(rb_intern("version")), INT2FIX(resp.version));
         VALUE services = rb_hash_new();
         rb_hash_aset(res, rb_id2sym(rb_intern("services")), services);
@@ -722,9 +1041,11 @@ cb_Backend_diagnostics(VALUE self, VALUE report_id)
                 if (svc.last_activity) {
                     rb_hash_aset(service, rb_id2sym(rb_intern("last_activity_us")), LL2NUM(svc.last_activity->count()));
                 }
-                rb_hash_aset(service, rb_id2sym(rb_intern("id")), rb_str_new(svc.id.data(), static_cast<long>(svc.id.size())));
-                rb_hash_aset(service, rb_id2sym(rb_intern("remote")), rb_str_new(svc.remote.data(), static_cast<long>(svc.remote.size())));
-                rb_hash_aset(service, rb_id2sym(rb_intern("local")), rb_str_new(svc.local.data(), static_cast<long>(svc.local.size())));
+                rb_hash_aset(service, rb_id2sym(rb_intern("id")), rb_external_str_new(svc.id.data(), static_cast<long>(svc.id.size())));
+                rb_hash_aset(
+                  service, rb_id2sym(rb_intern("remote")), rb_external_str_new(svc.remote.data(), static_cast<long>(svc.remote.size())));
+                rb_hash_aset(
+                  service, rb_id2sym(rb_intern("local")), rb_external_str_new(svc.local.data(), static_cast<long>(svc.local.size())));
                 VALUE state = Qnil;
                 switch (svc.state) {
                     case couchbase::diag::endpoint_state::disconnected:
@@ -741,8 +1062,9 @@ cb_Backend_diagnostics(VALUE self, VALUE report_id)
                         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("details")),
+                                 rb_external_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);
@@ -1182,8 +1504,8 @@ cb_Backend_ping(VALUE self, VALUE bucket, VALUE options)
         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("id")), rb_external_str_new(resp.id.data(), static_cast<long>(resp.id.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("sdk")), rb_external_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);
@@ -1214,9 +1536,11 @@ cb_Backend_ping(VALUE self, VALUE bucket, VALUE options)
             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())));
+                rb_hash_aset(service, rb_id2sym(rb_intern("id")), rb_external_str_new(svc.id.data(), static_cast<long>(svc.id.size())));
+                rb_hash_aset(
+                  service, rb_id2sym(rb_intern("remote")), rb_external_str_new(svc.remote.data(), static_cast<long>(svc.remote.size())));
+                rb_hash_aset(
+                  service, rb_id2sym(rb_intern("local")), rb_external_str_new(svc.local.data(), static_cast<long>(svc.local.size())));
                 VALUE state = Qnil;
                 switch (svc.state) {
                     case couchbase::diag::ping_state::ok:
@@ -1228,8 +1552,9 @@ cb_Backend_ping(VALUE self, VALUE bucket, VALUE options)
                     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())));
+                            rb_hash_aset(service,
+                                         rb_id2sym(rb_intern("error")),
+                                         rb_external_str_new(svc.error->data(), static_cast<long>(svc.error->size())));
                         }
                         break;
                 }
@@ -1274,13 +1599,13 @@ cb_Backend_document_get(VALUE self, VALUE bucket, VALUE collection, VALUE id, VA
         auto f = barrier->get_future();
         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(R"(unable fetch "{}" (opaque={}))", doc_id, resp.opaque));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable to fetch document");
             break;
         }
 
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, rb_id2sym(rb_intern("content")), rb_str_new(resp.value.data(), static_cast<long>(resp.value.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("content")), rb_external_str_new(resp.value.data(), static_cast<long>(resp.value.size())));
         rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
         rb_hash_aset(res, rb_id2sym(rb_intern("flags")), UINT2NUM(resp.flags));
         return res;
@@ -1332,12 +1657,11 @@ cb_Backend_document_get_multi(VALUE self, VALUE keys, VALUE options)
         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)));
+            if (resp.ctx.ec) {
+                rb_hash_aset(entry, rb_id2sym(rb_intern("error")), cb__map_error_code(resp.ctx, "unable to (multi)fetch document"));
             }
-            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("content")), rb_external_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);
@@ -1410,13 +1734,13 @@ cb_Backend_document_get_projected(VALUE self, VALUE bucket, VALUE collection, VA
         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(R"(unable fetch with projections "{}" (opaque={}))", doc_id, resp.opaque));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable fetch with projections");
             break;
         }
 
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, rb_id2sym(rb_intern("content")), rb_str_new(resp.value.data(), static_cast<long>(resp.value.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("content")), rb_external_str_new(resp.value.data(), static_cast<long>(resp.value.size())));
         rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
         rb_hash_aset(res, rb_id2sym(rb_intern("flags")), UINT2NUM(resp.flags));
         if (resp.expiry) {
@@ -1466,13 +1790,13 @@ cb_Backend_document_get_and_lock(VALUE self, VALUE bucket, VALUE collection, VAL
         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(R"(unable lock and fetch "{}" (opaque={}))", doc_id, resp.opaque));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable lock and fetch");
             break;
         }
 
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, rb_id2sym(rb_intern("content")), rb_str_new(resp.value.data(), static_cast<long>(resp.value.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("content")), rb_external_str_new(resp.value.data(), static_cast<long>(resp.value.size())));
         rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
         rb_hash_aset(res, rb_id2sym(rb_intern("flags")), UINT2NUM(resp.flags));
         return res;
@@ -1519,13 +1843,13 @@ cb_Backend_document_get_and_touch(VALUE self, VALUE bucket, VALUE collection, VA
         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(R"(unable fetch and touch "{}" (opaque={}))", doc_id, resp.opaque));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable fetch and touch");
             break;
         }
 
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, rb_id2sym(rb_intern("content")), rb_str_new(resp.value.data(), static_cast<long>(resp.value.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("content")), rb_external_str_new(resp.value.data(), static_cast<long>(resp.value.size())));
         rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
         rb_hash_aset(res, rb_id2sym(rb_intern("flags")), UINT2NUM(resp.flags));
         return res;
@@ -1542,11 +1866,11 @@ cb__extract_mutation_result(Response resp)
     rb_hash_aset(res, rb_id2sym(rb_intern("cas")), ULL2NUM(resp.cas));
     VALUE token = rb_hash_new();
     rb_hash_aset(token, rb_id2sym(rb_intern("partition_uuid")), ULL2NUM(resp.token.partition_uuid));
-    rb_hash_aset(token, rb_id2sym(rb_intern("sequence_number")), ULONG2NUM(resp.token.sequence_number));
+    rb_hash_aset(token, rb_id2sym(rb_intern("sequence_number")), ULL2NUM(resp.token.sequence_number));
     rb_hash_aset(token, rb_id2sym(rb_intern("partition_id")), UINT2NUM(resp.token.partition_id));
     rb_hash_aset(token,
                  rb_id2sym(rb_intern("bucket_name")),
-                 rb_str_new(resp.token.bucket_name.c_str(), static_cast<long>(resp.token.bucket_name.size())));
+                 rb_external_str_new(resp.token.bucket_name.c_str(), static_cast<long>(resp.token.bucket_name.size())));
     rb_hash_aset(res, rb_id2sym(rb_intern("mutation_token")), token);
     return res;
 }
@@ -1588,8 +1912,8 @@ cb_Backend_document_touch(VALUE self, VALUE bucket, VALUE collection, VALUE id,
         auto f = barrier->get_future();
         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(R"(unable to touch "{}" (opaque={}))", doc_id, resp.opaque));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable to touch");
             break;
         }
 
@@ -1636,8 +1960,8 @@ cb_Backend_document_exists(VALUE self, VALUE bucket, VALUE collection, VALUE id,
         auto f = barrier->get_future();
         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(R"(unable to exists "{}" (opaque={}))", doc_id, resp.opaque));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable to exists");
             break;
         }
 
@@ -1713,8 +2037,8 @@ cb_Backend_document_unlock(VALUE self, VALUE bucket, VALUE collection, VALUE id,
         auto f = barrier->get_future();
         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(R"(unable to unlock "{}" (opaque={}))", doc_id, resp.opaque));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable to unlock");
             break;
         }
 
@@ -1778,8 +2102,8 @@ cb_Backend_document_upsert(VALUE self, VALUE bucket, VALUE collection, VALUE id,
         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));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable to upsert");
             break;
         }
 
@@ -1850,10 +2174,8 @@ cb_Backend_document_upsert_multi(VALUE self, VALUE id_content, VALUE options)
         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)));
+            if (resp.ctx.ec) {
+                rb_hash_aset(entry, rb_id2sym(rb_intern("error")), cb__map_error_code(resp.ctx, "unable (multi)upsert"));
             }
             rb_ary_push(res, entry);
         }
@@ -1904,8 +2226,8 @@ cb_Backend_document_append(VALUE self, VALUE bucket, VALUE collection, VALUE id,
         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));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable to append");
             break;
         }
 
@@ -1956,8 +2278,8 @@ cb_Backend_document_prepend(VALUE self, VALUE bucket, VALUE collection, VALUE id
         auto f = barrier->get_future();
         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(R"(unable to prepend to "{}" (opaque={}))", doc_id, resp.opaque));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable to prepend");
             break;
         }
 
@@ -2027,8 +2349,8 @@ cb_Backend_document_replace(VALUE self, VALUE bucket, VALUE collection, VALUE id
         auto f = barrier->get_future();
         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(R"(unable to replace "{}" (opaque={}))", doc_id, resp.opaque));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable to replace");
             break;
         }
 
@@ -2090,8 +2412,8 @@ cb_Backend_document_insert(VALUE self, VALUE bucket, VALUE collection, VALUE id,
         auto f = barrier->get_future();
         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(R"(unable to insert "{}" (opaque={}))", doc_id, resp.opaque));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable to insert");
             break;
         }
 
@@ -2148,8 +2470,8 @@ cb_Backend_document_remove(VALUE self, VALUE bucket, VALUE collection, VALUE id,
         auto f = barrier->get_future();
         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(R"(unable to remove "{}" (opaque={}))", doc_id, resp.opaque));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable to remove");
             break;
         }
         return cb__extract_mutation_result(resp);
@@ -2215,10 +2537,8 @@ cb_Backend_document_remove_multi(VALUE self, VALUE id_cas, VALUE options)
         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)));
+            if (resp.ctx.ec) {
+                rb_hash_aset(entry, rb_id2sym(rb_intern("error")), cb__map_error_code(resp.ctx, "unable (multi)remove"));
             }
             rb_ary_push(res, entry);
         }
@@ -2292,8 +2612,8 @@ cb_Backend_document_increment(VALUE self, VALUE bucket, VALUE collection, VALUE
         auto f = barrier->get_future();
         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(R"(unable to increment "{}" by {} (opaque={}))", doc_id, req.delta, resp.opaque));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx.ec, fmt::format(R"(unable to increment by {})", req.delta));
             break;
         }
         VALUE res = cb__extract_mutation_result(resp);
@@ -2367,8 +2687,8 @@ cb_Backend_document_decrement(VALUE self, VALUE bucket, VALUE collection, VALUE
         auto f = barrier->get_future();
         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(R"(unable to decrement "{}" by {} (opaque={}))", doc_id, req.delta, resp.opaque));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, fmt::format(R"(unable to decrement by {})", req.delta));
             break;
         }
         VALUE res = cb__extract_mutation_result(resp);
@@ -2626,8 +2946,8 @@ cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE collection, VALUE
         auto f = barrier->get_future();
         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(R"(unable fetch "{}" (opaque={}))", doc_id, resp.opaque));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable fetch");
             break;
         }
 
@@ -2642,11 +2962,12 @@ cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE collection, VALUE
             VALUE entry = rb_hash_new();
             rb_hash_aset(entry, rb_id2sym(rb_intern("index")), ULL2NUM(i));
             rb_hash_aset(entry, rb_id2sym(rb_intern("exists")), resp.fields[i].exists ? Qtrue : Qfalse);
-            rb_hash_aset(
-              entry, rb_id2sym(rb_intern("path")), rb_str_new(resp.fields[i].path.data(), static_cast<long>(resp.fields[i].path.size())));
+            rb_hash_aset(entry,
+                         rb_id2sym(rb_intern("path")),
+                         rb_external_str_new(resp.fields[i].path.data(), static_cast<long>(resp.fields[i].path.size())));
             rb_hash_aset(entry,
                          rb_id2sym(rb_intern("value")),
-                         rb_str_new(resp.fields[i].value.data(), static_cast<long>(resp.fields[i].value.size())));
+                         rb_external_str_new(resp.fields[i].value.data(), static_cast<long>(resp.fields[i].value.size())));
             cb__map_subdoc_status(resp.fields[i].status, i, resp.fields[i].path, entry);
             if (resp.fields[i].opcode == couchbase::protocol::subdoc_opcode::get && resp.fields[i].path.empty()) {
                 rb_hash_aset(entry, rb_id2sym(rb_intern("type")), rb_id2sym(rb_intern("get_doc")));
@@ -2805,14 +3126,14 @@ cb_Backend_document_mutate_in(VALUE self, VALUE bucket, VALUE collection, VALUE
         auto f = barrier->get_future();
         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(R"(unable to mutate "{}" (opaque={}))", doc_id, resp.opaque));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable to mutate");
             break;
         }
 
         VALUE res = cb__extract_mutation_result(resp);
         if (resp.first_error_index) {
-            rb_hash_aset(res, rb_id2sym(rb_intern("first_error_index")), ULONG2NUM(resp.first_error_index.value()));
+            rb_hash_aset(res, rb_id2sym(rb_intern("first_error_index")), ULL2NUM(resp.first_error_index.value()));
         }
         if (resp.deleted) {
             rb_hash_aset(res, rb_id2sym(rb_intern("deleted")), Qtrue);
@@ -2822,18 +3143,19 @@ cb_Backend_document_mutate_in(VALUE self, VALUE bucket, VALUE collection, VALUE
         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));
-            rb_hash_aset(
-              entry, rb_id2sym(rb_intern("path")), rb_str_new(resp.fields[i].path.data(), static_cast<long>(resp.fields[i].path.size())));
+            rb_hash_aset(entry,
+                         rb_id2sym(rb_intern("path")),
+                         rb_external_str_new(resp.fields[i].path.data(), static_cast<long>(resp.fields[i].path.size())));
             if (resp.fields[i].status == couchbase::protocol::status::success ||
                 resp.fields[i].status == couchbase::protocol::status::subdoc_success_deleted) {
                 if (resp.fields[i].opcode == couchbase::protocol::subdoc_opcode::counter) {
-                    if (resp.fields[i].value.size() > 0) {
-                        rb_hash_aset(entry, rb_id2sym(rb_intern("value")), LONG2NUM(std::stoll(resp.fields[i].value)));
+                    if (!resp.fields[i].value.empty()) {
+                        rb_hash_aset(entry, rb_id2sym(rb_intern("value")), LL2NUM(std::stoll(resp.fields[i].value)));
                     }
                 } else {
                     rb_hash_aset(entry,
                                  rb_id2sym(rb_intern("value")),
-                                 rb_str_new(resp.fields[i].value.data(), static_cast<long>(resp.fields[i].value.size())));
+                                 rb_external_str_new(resp.fields[i].value.data(), static_cast<long>(resp.fields[i].value.size())));
                 }
             }
             cb__map_subdoc_status(resp.fields[i].status, i, resp.fields[i].path, entry);
@@ -3022,22 +3344,12 @@ cb_Backend_document_query(VALUE self, VALUE statement, VALUE options)
         auto f = barrier->get_future();
         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.ctx.ec) {
             if (resp.payload.meta_data.errors && !resp.payload.meta_data.errors->empty()) {
                 const auto& first_error = resp.payload.meta_data.errors->front();
-                exc = cb__map_error_code(resp.ec,
-                                         fmt::format(R"(unable to query (client_context_id="{}"): "{}{}" ({}: {}))",
-                                                     req.client_context_id,
-                                                     req.statement.substr(0, 100),
-                                                     req.statement.size() > 100 ? "..." : "",
-                                                     first_error.code,
-                                                     first_error.message));
+                exc = cb__map_error_code(resp.ctx, fmt::format(R"(unable to query ({}: {}))", first_error.code, first_error.message));
             } else {
-                exc = cb__map_error_code(resp.ec,
-                                         fmt::format(R"(unable to query (client_context_id="{}"): "{}{}")",
-                                                     req.client_context_id,
-                                                     req.statement.substr(0, 100),
-                                                     req.statement.size() > 100 ? "..." : ""));
+                exc = cb__map_error_code(resp.ctx, "unable to query");
             }
             break;
         }
@@ -3045,43 +3357,46 @@ cb_Backend_document_query(VALUE self, VALUE statement, VALUE options)
         VALUE rows = rb_ary_new_capa(static_cast<long>(resp.payload.rows.size()));
         rb_hash_aset(res, rb_id2sym(rb_intern("rows")), rows);
         for (auto& row : resp.payload.rows) {
-            rb_ary_push(rows, rb_str_new(row.data(), static_cast<long>(row.size())));
+            rb_ary_push(rows, rb_external_str_new(row.data(), static_cast<long>(row.size())));
         }
         VALUE meta = rb_hash_new();
         rb_hash_aset(res, rb_id2sym(rb_intern("meta")), meta);
         rb_hash_aset(meta,
                      rb_id2sym(rb_intern("status")),
                      rb_id2sym(rb_intern2(resp.payload.meta_data.status.data(), static_cast<long>(resp.payload.meta_data.status.size()))));
-        rb_hash_aset(meta,
-                     rb_id2sym(rb_intern("request_id")),
-                     rb_str_new(resp.payload.meta_data.request_id.data(), static_cast<long>(resp.payload.meta_data.request_id.size())));
         rb_hash_aset(
           meta,
-          rb_id2sym(rb_intern("client_context_id")),
-          rb_str_new(resp.payload.meta_data.client_context_id.data(), static_cast<long>(resp.payload.meta_data.client_context_id.size())));
+          rb_id2sym(rb_intern("request_id")),
+          rb_external_str_new(resp.payload.meta_data.request_id.data(), static_cast<long>(resp.payload.meta_data.request_id.size())));
+        rb_hash_aset(meta,
+                     rb_id2sym(rb_intern("client_context_id")),
+                     rb_external_str_new(resp.payload.meta_data.client_context_id.data(),
+                                         static_cast<long>(resp.payload.meta_data.client_context_id.size())));
         if (resp.payload.meta_data.signature) {
-            rb_hash_aset(meta,
-                         rb_id2sym(rb_intern("signature")),
-                         rb_str_new(resp.payload.meta_data.signature->data(), static_cast<long>(resp.payload.meta_data.signature->size())));
+            rb_hash_aset(
+              meta,
+              rb_id2sym(rb_intern("signature")),
+              rb_external_str_new(resp.payload.meta_data.signature->data(), static_cast<long>(resp.payload.meta_data.signature->size())));
         }
         if (resp.payload.meta_data.profile) {
-            rb_hash_aset(meta,
-                         rb_id2sym(rb_intern("profile")),
-                         rb_str_new(resp.payload.meta_data.profile->data(), static_cast<long>(resp.payload.meta_data.profile->size())));
+            rb_hash_aset(
+              meta,
+              rb_id2sym(rb_intern("profile")),
+              rb_external_str_new(resp.payload.meta_data.profile->data(), static_cast<long>(resp.payload.meta_data.profile->size())));
         }
         metrics = rb_hash_new();
         rb_hash_aset(meta, rb_id2sym(rb_intern("metrics")), metrics);
         if (!resp.payload.meta_data.metrics.elapsed_time.empty()) {
             rb_hash_aset(metrics,
                          rb_id2sym(rb_intern("elapsed_time")),
-                         rb_str_new(resp.payload.meta_data.metrics.elapsed_time.data(),
-                                    static_cast<long>(resp.payload.meta_data.metrics.elapsed_time.size())));
+                         rb_external_str_new(resp.payload.meta_data.metrics.elapsed_time.data(),
+                                             static_cast<long>(resp.payload.meta_data.metrics.elapsed_time.size())));
         }
         if (!resp.payload.meta_data.metrics.execution_time.empty()) {
             rb_hash_aset(metrics,
                          rb_id2sym(rb_intern("execution_time")),
-                         rb_str_new(resp.payload.meta_data.metrics.execution_time.data(),
-                                    static_cast<long>(resp.payload.meta_data.metrics.execution_time.size())));
+                         rb_external_str_new(resp.payload.meta_data.metrics.execution_time.data(),
+                                             static_cast<long>(resp.payload.meta_data.metrics.execution_time.size())));
         }
         rb_hash_aset(metrics, rb_id2sym(rb_intern("result_count")), ULL2NUM(resp.payload.meta_data.metrics.result_count));
         rb_hash_aset(metrics, rb_id2sym(rb_intern("result_size")), ULL2NUM(resp.payload.meta_data.metrics.result_size));
@@ -3104,44 +3419,60 @@ cb_Backend_document_query(VALUE self, VALUE statement, VALUE options)
     return Qnil;
 }
 
-static void
+static VALUE
 cb__generate_bucket_settings(VALUE bucket, couchbase::operations::bucket_settings& entry, bool is_create)
 {
     {
         VALUE bucket_type = rb_hash_aref(bucket, rb_id2sym(rb_intern("bucket_type")));
-        Check_Type(bucket_type, T_SYMBOL);
-        if (bucket_type == rb_id2sym(rb_intern("couchbase")) || bucket_type == rb_id2sym(rb_intern("membase"))) {
-            entry.bucket_type = couchbase::operations::bucket_settings::bucket_type::couchbase;
-        } else if (bucket_type == rb_id2sym(rb_intern("memcached"))) {
-            entry.bucket_type = couchbase::operations::bucket_settings::bucket_type::memcached;
-        } else if (bucket_type == rb_id2sym(rb_intern("ephemeral"))) {
-            entry.bucket_type = couchbase::operations::bucket_settings::bucket_type::ephemeral;
+        if (TYPE(bucket_type) == T_SYMBOL) {
+            if (bucket_type == rb_id2sym(rb_intern("couchbase")) || bucket_type == rb_id2sym(rb_intern("membase"))) {
+                entry.bucket_type = couchbase::operations::bucket_settings::bucket_type::couchbase;
+            } else if (bucket_type == rb_id2sym(rb_intern("memcached"))) {
+                entry.bucket_type = couchbase::operations::bucket_settings::bucket_type::memcached;
+            } else if (bucket_type == rb_id2sym(rb_intern("ephemeral"))) {
+                entry.bucket_type = couchbase::operations::bucket_settings::bucket_type::ephemeral;
+            } else {
+                return rb_exc_new_str(rb_eArgError, rb_sprintf("unknown bucket type, given %+" PRIsVALUE, bucket_type));
+            }
         } else {
-            rb_raise(rb_eArgError, "unknown bucket type");
+            return rb_exc_new_str(rb_eArgError, rb_sprintf("bucket type must be a Symbol, given %+" PRIsVALUE, bucket_type));
         }
     }
     {
         VALUE name = rb_hash_aref(bucket, rb_id2sym(rb_intern("name")));
-        Check_Type(name, T_STRING);
-        entry.name.assign(RSTRING_PTR(name), static_cast<size_t>(RSTRING_LEN(name)));
+        if (TYPE(name) == T_STRING) {
+            entry.name.assign(RSTRING_PTR(name), static_cast<size_t>(RSTRING_LEN(name)));
+        } else {
+            return rb_exc_new_str(rb_eArgError, rb_sprintf("bucket name must be a String, given %+" PRIsVALUE, name));
+        }
     }
     {
         VALUE quota = rb_hash_aref(bucket, rb_id2sym(rb_intern("ram_quota_mb")));
-        Check_Type(quota, T_FIXNUM);
-        entry.ram_quota_mb = FIX2ULONG(quota);
+        if (TYPE(quota) == T_FIXNUM) {
+            entry.ram_quota_mb = FIX2ULONG(quota);
+        } else {
+            return rb_exc_new_str(rb_eArgError, rb_sprintf("bucket RAM quota must be an Integer, given %+" PRIsVALUE, quota));
+        }
     }
     {
         VALUE expiry = rb_hash_aref(bucket, rb_id2sym(rb_intern("max_expiry")));
         if (!NIL_P(expiry)) {
-            Check_Type(expiry, T_FIXNUM);
-            entry.max_expiry = FIX2UINT(expiry);
+            if (TYPE(expiry) == T_FIXNUM) {
+                entry.max_expiry = FIX2UINT(expiry);
+            } else {
+                return rb_exc_new_str(rb_eArgError, rb_sprintf("bucket max expiry must be an Integer, given %+" PRIsVALUE, expiry));
+            }
         }
     }
     {
         VALUE num_replicas = rb_hash_aref(bucket, rb_id2sym(rb_intern("num_replicas")));
         if (!NIL_P(num_replicas)) {
-            Check_Type(num_replicas, T_FIXNUM);
-            entry.num_replicas = FIX2UINT(num_replicas);
+            if (TYPE(num_replicas) == T_FIXNUM) {
+                entry.num_replicas = FIX2UINT(num_replicas);
+            } else {
+                return rb_exc_new_str(rb_eArgError,
+                                      rb_sprintf("bucket number of replicas must be an Integer, given %+" PRIsVALUE, num_replicas));
+            }
         }
     }
     {
@@ -3159,48 +3490,84 @@ cb__generate_bucket_settings(VALUE bucket, couchbase::operations::bucket_setting
     {
         VALUE compression_mode = rb_hash_aref(bucket, rb_id2sym(rb_intern("compression_mode")));
         if (!NIL_P(compression_mode)) {
-            Check_Type(compression_mode, T_SYMBOL);
-            if (compression_mode == rb_id2sym(rb_intern("active"))) {
-                entry.compression_mode = couchbase::operations::bucket_settings::compression_mode::active;
-            } else if (compression_mode == rb_id2sym(rb_intern("passive"))) {
-                entry.compression_mode = couchbase::operations::bucket_settings::compression_mode::passive;
-            } else if (compression_mode == rb_id2sym(rb_intern("off"))) {
-                entry.compression_mode = couchbase::operations::bucket_settings::compression_mode::off;
+            if (TYPE(compression_mode) == T_SYMBOL) {
+                if (compression_mode == rb_id2sym(rb_intern("active"))) {
+                    entry.compression_mode = couchbase::operations::bucket_settings::compression_mode::active;
+                } else if (compression_mode == rb_id2sym(rb_intern("passive"))) {
+                    entry.compression_mode = couchbase::operations::bucket_settings::compression_mode::passive;
+                } else if (compression_mode == rb_id2sym(rb_intern("off"))) {
+                    entry.compression_mode = couchbase::operations::bucket_settings::compression_mode::off;
+                } else {
+                    return rb_exc_new_str(rb_eArgError, rb_sprintf("unknown compression mode, given %+" PRIsVALUE, compression_mode));
+                }
             } else {
-                rb_raise(rb_eArgError, "unknown compression mode");
+                return rb_exc_new_str(rb_eArgError,
+                                      rb_sprintf("bucket compression mode must be a Symbol, given %+" PRIsVALUE, compression_mode));
             }
         }
     }
     {
         VALUE eviction_policy = rb_hash_aref(bucket, rb_id2sym(rb_intern("eviction_policy")));
         if (!NIL_P(eviction_policy)) {
-            Check_Type(eviction_policy, T_SYMBOL);
-            if (eviction_policy == rb_id2sym(rb_intern("full"))) {
-                entry.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::full;
-            } else if (eviction_policy == rb_id2sym(rb_intern("value_only"))) {
-                entry.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::value_only;
-            } else if (eviction_policy == rb_id2sym(rb_intern("no_eviction"))) {
-                entry.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::no_eviction;
-            } else if (eviction_policy == rb_id2sym(rb_intern("not_recently_used"))) {
-                entry.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::not_recently_used;
+            if (TYPE(eviction_policy) == T_SYMBOL) {
+                if (eviction_policy == rb_id2sym(rb_intern("full"))) {
+                    entry.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::full;
+                } else if (eviction_policy == rb_id2sym(rb_intern("value_only"))) {
+                    entry.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::value_only;
+                } else if (eviction_policy == rb_id2sym(rb_intern("no_eviction"))) {
+                    entry.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::no_eviction;
+                } else if (eviction_policy == rb_id2sym(rb_intern("not_recently_used"))) {
+                    entry.eviction_policy = couchbase::operations::bucket_settings::eviction_policy::not_recently_used;
+                } else {
+                    return rb_exc_new_str(rb_eArgError, rb_sprintf("unknown eviction policy, given %+" PRIsVALUE, eviction_policy));
+                }
             } else {
-                rb_raise(rb_eArgError, "unknown eviction policy");
+                return rb_exc_new_str(rb_eArgError,
+                                      rb_sprintf("bucket eviction policy must be a Symbol, given %+" PRIsVALUE, eviction_policy));
+            }
+        }
+    }
+    {
+        VALUE minimum_level = rb_hash_aref(bucket, rb_id2sym(rb_intern("minimum_durability_level")));
+        if (!NIL_P(minimum_level)) {
+            if (TYPE(minimum_level) == T_SYMBOL) {
+                if (minimum_level == rb_id2sym(rb_intern("none"))) {
+                    entry.minimum_durability_level = couchbase::protocol::durability_level::none;
+                } else if (minimum_level == rb_id2sym(rb_intern("majority"))) {
+                    entry.minimum_durability_level = couchbase::protocol::durability_level::majority;
+                } else if (minimum_level == rb_id2sym(rb_intern("majority_and_persist_to_active"))) {
+                    entry.minimum_durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
+                } else if (minimum_level == rb_id2sym(rb_intern("persist_to_majority"))) {
+                    entry.minimum_durability_level = couchbase::protocol::durability_level::persist_to_majority;
+                } else {
+                    return rb_exc_new_str(rb_eArgError, rb_sprintf("unknown durability level, given %+" PRIsVALUE, minimum_level));
+                }
+            } else {
+                return rb_exc_new_str(rb_eArgError,
+                                      rb_sprintf("bucket minimum durability level must be a Symbol, given %+" PRIsVALUE, minimum_level));
             }
         }
     }
     if (is_create) {
         VALUE conflict_resolution_type = rb_hash_aref(bucket, rb_id2sym(rb_intern("conflict_resolution_type")));
         if (!NIL_P(conflict_resolution_type)) {
-            Check_Type(conflict_resolution_type, T_SYMBOL);
-            if (conflict_resolution_type == rb_id2sym(rb_intern("timestamp"))) {
-                entry.conflict_resolution_type = couchbase::operations::bucket_settings::conflict_resolution_type::timestamp;
-            } else if (conflict_resolution_type == rb_id2sym(rb_intern("sequence_number"))) {
-                entry.conflict_resolution_type = couchbase::operations::bucket_settings::conflict_resolution_type::sequence_number;
+            if (TYPE(conflict_resolution_type) == T_SYMBOL) {
+                if (conflict_resolution_type == rb_id2sym(rb_intern("timestamp"))) {
+                    entry.conflict_resolution_type = couchbase::operations::bucket_settings::conflict_resolution_type::timestamp;
+                } else if (conflict_resolution_type == rb_id2sym(rb_intern("sequence_number"))) {
+                    entry.conflict_resolution_type = couchbase::operations::bucket_settings::conflict_resolution_type::sequence_number;
+                } else {
+                    return rb_exc_new_str(rb_eArgError,
+                                          rb_sprintf("unknown conflict resolution type, given %+" PRIsVALUE, conflict_resolution_type));
+                }
             } else {
-                rb_raise(rb_eArgError, "unknown conflict resolution type");
+                return rb_exc_new_str(
+                  rb_eArgError,
+                  rb_sprintf("bucket conflict resulution type must be a Symbol, given %+" PRIsVALUE, conflict_resolution_type));
             }
         }
     }
+    return Qnil;
 }
 
 static VALUE
@@ -3223,15 +3590,18 @@ cb_Backend_bucket_create(VALUE self, VALUE bucket_settings, VALUE timeout)
         if (!NIL_P(exc)) {
             break;
         }
-        cb__generate_bucket_settings(bucket_settings, req.bucket, true);
+        exc = cb__generate_bucket_settings(bucket_settings, req.bucket, true);
+        if (!NIL_P(exc)) {
+            break;
+        }
         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); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             exc = cb__map_error_code(
-              resp.ec, fmt::format("unable to create bucket \"{}\" on the cluster ({})", req.bucket.name, resp.error_message));
+              resp.ctx, fmt::format("unable to create bucket \"{}\" on the cluster ({})", req.bucket.name, resp.error_message));
             break;
         }
 
@@ -3260,15 +3630,18 @@ cb_Backend_bucket_update(VALUE self, VALUE bucket_settings, VALUE timeout)
         if (!NIL_P(exc)) {
             break;
         }
-        cb__generate_bucket_settings(bucket_settings, req.bucket, false);
+        exc = cb__generate_bucket_settings(bucket_settings, req.bucket, false);
+        if (!NIL_P(exc)) {
+            break;
+        }
         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); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             exc = cb__map_error_code(
-              resp.ec, fmt::format("unable to update bucket \"{}\" on the cluster ({})", req.bucket.name, resp.error_message));
+              resp.ctx, fmt::format("unable to update bucket \"{}\" on the cluster ({})", req.bucket.name, resp.error_message));
             break;
         }
         return Qtrue;
@@ -3303,8 +3676,8 @@ cb_Backend_bucket_drop(VALUE self, VALUE bucket_name, VALUE timeout)
         backend->cluster->execute_http(req,
                                        [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));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, fmt::format("unable to remove bucket \"{}\" on the cluster", req.name));
             break;
         }
         return Qtrue;
@@ -3339,8 +3712,8 @@ cb_Backend_bucket_flush(VALUE self, VALUE bucket_name, VALUE timeout)
         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));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, fmt::format("unable to flush bucket \"{}\" on the cluster", req.name));
             break;
         }
 
@@ -3367,8 +3740,8 @@ cb__extract_bucket_settings(const couchbase::operations::bucket_settings& entry,
             rb_hash_aset(bucket, rb_id2sym(rb_intern("bucket_type")), Qnil);
             break;
     }
-    rb_hash_aset(bucket, rb_id2sym(rb_intern("name")), rb_str_new(entry.name.data(), static_cast<long>(entry.name.size())));
-    rb_hash_aset(bucket, rb_id2sym(rb_intern("uuid")), rb_str_new(entry.uuid.data(), static_cast<long>(entry.uuid.size())));
+    rb_hash_aset(bucket, rb_id2sym(rb_intern("name")), rb_external_str_new(entry.name.data(), static_cast<long>(entry.name.size())));
+    rb_hash_aset(bucket, rb_id2sym(rb_intern("uuid")), rb_external_str_new(entry.uuid.data(), static_cast<long>(entry.uuid.size())));
     rb_hash_aset(bucket, rb_id2sym(rb_intern("ram_quota_mb")), ULL2NUM(entry.ram_quota_mb));
     rb_hash_aset(bucket, rb_id2sym(rb_intern("max_expiry")), ULONG2NUM(entry.max_expiry));
     switch (entry.compression_mode) {
@@ -3416,17 +3789,34 @@ cb__extract_bucket_settings(const couchbase::operations::bucket_settings& entry,
             rb_hash_aset(bucket, rb_id2sym(rb_intern("conflict_resolution_type")), Qnil);
             break;
     }
+    if (entry.minimum_durability_level) {
+        switch (entry.minimum_durability_level.value()) {
+            case couchbase::protocol::durability_level::none:
+                rb_hash_aset(bucket, rb_id2sym(rb_intern("minimum_durability_level")), rb_id2sym(rb_intern("none")));
+                break;
+            case couchbase::protocol::durability_level::majority:
+                rb_hash_aset(bucket, rb_id2sym(rb_intern("minimum_durability_level")), rb_id2sym(rb_intern("majority")));
+                break;
+            case couchbase::protocol::durability_level::majority_and_persist_to_active:
+                rb_hash_aset(
+                  bucket, rb_id2sym(rb_intern("minimum_durability_level")), rb_id2sym(rb_intern("majority_and_persist_to_active")));
+                break;
+            case couchbase::protocol::durability_level::persist_to_majority:
+                rb_hash_aset(bucket, rb_id2sym(rb_intern("minimum_durability_level")), rb_id2sym(rb_intern("persist_to_majority")));
+                break;
+        }
+    }
     VALUE capabilities = rb_ary_new_capa(static_cast<long>(entry.capabilities.size()));
     for (const auto& capa : entry.capabilities) {
-        rb_ary_push(capabilities, rb_str_new(capa.data(), static_cast<long>(capa.size())));
+        rb_ary_push(capabilities, rb_external_str_new(capa.data(), static_cast<long>(capa.size())));
     }
     rb_hash_aset(bucket, rb_id2sym(rb_intern("capabilities")), capabilities);
     VALUE nodes = rb_ary_new_capa(static_cast<long>(entry.nodes.size()));
     for (const auto& n : entry.nodes) {
         VALUE node = rb_hash_new();
-        rb_hash_aset(node, rb_id2sym(rb_intern("status")), rb_str_new(n.status.data(), static_cast<long>(n.status.size())));
-        rb_hash_aset(node, rb_id2sym(rb_intern("hostname")), rb_str_new(n.hostname.data(), static_cast<long>(n.hostname.size())));
-        rb_hash_aset(node, rb_id2sym(rb_intern("version")), rb_str_new(n.version.data(), static_cast<long>(n.version.size())));
+        rb_hash_aset(node, rb_id2sym(rb_intern("status")), rb_external_str_new(n.status.data(), static_cast<long>(n.status.size())));
+        rb_hash_aset(node, rb_id2sym(rb_intern("hostname")), rb_external_str_new(n.hostname.data(), static_cast<long>(n.hostname.size())));
+        rb_hash_aset(node, rb_id2sym(rb_intern("version")), rb_external_str_new(n.version.data(), static_cast<long>(n.version.size())));
         rb_ary_push(nodes, node);
     }
     rb_hash_aset(bucket, rb_id2sym(rb_intern("nodes")), nodes);
@@ -3455,8 +3845,8 @@ cb_Backend_bucket_get_all(VALUE self, VALUE timeout)
         backend->cluster->execute_http(
           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");
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable to get list of the buckets of the cluster");
             break;
         }
 
@@ -3499,8 +3889,8 @@ cb_Backend_bucket_get(VALUE self, VALUE bucket_name, VALUE timeout)
         backend->cluster->execute_http(req,
                                        [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));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, fmt::format("unable to locate bucket \"{}\" on the cluster", req.name));
             break;
         }
 
@@ -3516,20 +3906,24 @@ cb_Backend_bucket_get(VALUE self, VALUE bucket_name, VALUE timeout)
 static void
 cb__extract_role(const couchbase::operations::rbac::role_and_description& entry, VALUE role)
 {
-    rb_hash_aset(role, rb_id2sym(rb_intern("name")), rb_str_new(entry.name.data(), static_cast<long>(entry.name.size())));
-    rb_hash_aset(
-      role, rb_id2sym(rb_intern("display_name")), rb_str_new(entry.display_name.data(), static_cast<long>(entry.display_name.size())));
-    rb_hash_aset(
-      role, rb_id2sym(rb_intern("description")), rb_str_new(entry.description.data(), static_cast<long>(entry.description.size())));
+    rb_hash_aset(role, rb_id2sym(rb_intern("name")), rb_external_str_new(entry.name.data(), static_cast<long>(entry.name.size())));
+    rb_hash_aset(role,
+                 rb_id2sym(rb_intern("display_name")),
+                 rb_external_str_new(entry.display_name.data(), static_cast<long>(entry.display_name.size())));
+    rb_hash_aset(role,
+                 rb_id2sym(rb_intern("description")),
+                 rb_external_str_new(entry.description.data(), static_cast<long>(entry.description.size())));
     if (entry.bucket) {
-        rb_hash_aset(role, rb_id2sym(rb_intern("bucket")), rb_str_new(entry.bucket->data(), static_cast<long>(entry.bucket->size())));
+        rb_hash_aset(
+          role, rb_id2sym(rb_intern("bucket")), rb_external_str_new(entry.bucket->data(), static_cast<long>(entry.bucket->size())));
     }
     if (entry.scope) {
-        rb_hash_aset(role, rb_id2sym(rb_intern("scope")), rb_str_new(entry.scope->data(), static_cast<long>(entry.scope->size())));
+        rb_hash_aset(role, rb_id2sym(rb_intern("scope")), rb_external_str_new(entry.scope->data(), static_cast<long>(entry.scope->size())));
     }
     if (entry.collection) {
-        rb_hash_aset(
-          role, rb_id2sym(rb_intern("collection")), rb_str_new(entry.collection->data(), static_cast<long>(entry.collection->size())));
+        rb_hash_aset(role,
+                     rb_id2sym(rb_intern("collection")),
+                     rb_external_str_new(entry.collection->data(), static_cast<long>(entry.collection->size())));
     }
 }
 
@@ -3556,8 +3950,8 @@ cb_Backend_role_get_all(VALUE self, VALUE timeout)
         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");
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable to fetch roles");
             break;
         }
 
@@ -3576,7 +3970,8 @@ cb_Backend_role_get_all(VALUE self, VALUE timeout)
 static void
 cb__extract_user(const couchbase::operations::rbac::user_and_metadata& entry, VALUE user)
 {
-    rb_hash_aset(user, rb_id2sym(rb_intern("username")), rb_str_new(entry.username.data(), static_cast<long>(entry.username.size())));
+    rb_hash_aset(
+      user, rb_id2sym(rb_intern("username")), rb_external_str_new(entry.username.data(), static_cast<long>(entry.username.size())));
     switch (entry.domain) {
         case couchbase::operations::rbac::auth_domain::local:
             rb_hash_aset(user, rb_id2sym(rb_intern("domain")), rb_id2sym(rb_intern("local")));
@@ -3589,44 +3984,47 @@ cb__extract_user(const couchbase::operations::rbac::user_and_metadata& entry, VA
     }
     VALUE external_groups = rb_ary_new_capa(static_cast<long>(entry.external_groups.size()));
     for (const auto& group : entry.external_groups) {
-        rb_ary_push(external_groups, rb_str_new(group.data(), static_cast<long>(group.size())));
+        rb_ary_push(external_groups, rb_external_str_new(group.data(), static_cast<long>(group.size())));
     }
     rb_hash_aset(user, rb_id2sym(rb_intern("external_groups")), external_groups);
     VALUE groups = rb_ary_new_capa(static_cast<long>(entry.groups.size()));
     for (const auto& group : entry.groups) {
-        rb_ary_push(groups, rb_str_new(group.data(), static_cast<long>(group.size())));
+        rb_ary_push(groups, rb_external_str_new(group.data(), static_cast<long>(group.size())));
     }
     rb_hash_aset(user, rb_id2sym(rb_intern("groups")), groups);
     if (entry.display_name) {
         rb_hash_aset(user,
                      rb_id2sym(rb_intern("display_name")),
-                     rb_str_new(entry.display_name->data(), static_cast<long>(entry.display_name->size())));
+                     rb_external_str_new(entry.display_name->data(), static_cast<long>(entry.display_name->size())));
     }
     if (entry.password_changed) {
         rb_hash_aset(user,
                      rb_id2sym(rb_intern("password_changed")),
-                     rb_str_new(entry.password_changed->data(), static_cast<long>(entry.password_changed->size())));
+                     rb_external_str_new(entry.password_changed->data(), static_cast<long>(entry.password_changed->size())));
     }
     VALUE effective_roles = rb_ary_new_capa(static_cast<long>(entry.effective_roles.size()));
     for (const auto& er : entry.effective_roles) {
         VALUE role = rb_hash_new();
-        rb_hash_aset(role, rb_id2sym(rb_intern("name")), rb_str_new(er.name.data(), static_cast<long>(er.name.size())));
+        rb_hash_aset(role, rb_id2sym(rb_intern("name")), rb_external_str_new(er.name.data(), static_cast<long>(er.name.size())));
         if (er.bucket) {
-            rb_hash_aset(role, rb_id2sym(rb_intern("bucket")), rb_str_new(er.bucket->data(), static_cast<long>(er.bucket->size())));
+            rb_hash_aset(
+              role, rb_id2sym(rb_intern("bucket")), rb_external_str_new(er.bucket->data(), static_cast<long>(er.bucket->size())));
         }
         if (er.scope) {
-            rb_hash_aset(role, rb_id2sym(rb_intern("scope")), rb_str_new(er.scope->data(), static_cast<long>(er.scope->size())));
+            rb_hash_aset(role, rb_id2sym(rb_intern("scope")), rb_external_str_new(er.scope->data(), static_cast<long>(er.scope->size())));
         }
         if (er.collection) {
-            rb_hash_aset(
-              role, rb_id2sym(rb_intern("collection")), rb_str_new(er.collection->data(), static_cast<long>(er.collection->size())));
+            rb_hash_aset(role,
+                         rb_id2sym(rb_intern("collection")),
+                         rb_external_str_new(er.collection->data(), static_cast<long>(er.collection->size())));
         }
         VALUE origins = rb_ary_new_capa(static_cast<long>(er.origins.size()));
         for (const auto& orig : er.origins) {
             VALUE origin = rb_hash_new();
-            rb_hash_aset(origin, rb_id2sym(rb_intern("type")), rb_str_new(orig.type.data(), static_cast<long>(orig.type.size())));
+            rb_hash_aset(origin, rb_id2sym(rb_intern("type")), rb_external_str_new(orig.type.data(), static_cast<long>(orig.type.size())));
             if (orig.name) {
-                rb_hash_aset(origin, rb_id2sym(rb_intern("name")), rb_str_new(orig.name->data(), static_cast<long>(orig.name->size())));
+                rb_hash_aset(
+                  origin, rb_id2sym(rb_intern("name")), rb_external_str_new(orig.name->data(), static_cast<long>(orig.name->size())));
             }
             rb_ary_push(origins, origin);
         }
@@ -3638,16 +4036,18 @@ cb__extract_user(const couchbase::operations::rbac::user_and_metadata& entry, VA
     VALUE roles = rb_ary_new_capa(static_cast<long>(entry.roles.size()));
     for (const auto& er : entry.roles) {
         VALUE role = rb_hash_new();
-        rb_hash_aset(role, rb_id2sym(rb_intern("name")), rb_str_new(er.name.data(), static_cast<long>(er.name.size())));
+        rb_hash_aset(role, rb_id2sym(rb_intern("name")), rb_external_str_new(er.name.data(), static_cast<long>(er.name.size())));
         if (er.bucket) {
-            rb_hash_aset(role, rb_id2sym(rb_intern("bucket")), rb_str_new(er.bucket->data(), static_cast<long>(er.bucket->size())));
+            rb_hash_aset(
+              role, rb_id2sym(rb_intern("bucket")), rb_external_str_new(er.bucket->data(), static_cast<long>(er.bucket->size())));
         }
         if (er.scope) {
-            rb_hash_aset(role, rb_id2sym(rb_intern("scope")), rb_str_new(er.scope->data(), static_cast<long>(er.scope->size())));
+            rb_hash_aset(role, rb_id2sym(rb_intern("scope")), rb_external_str_new(er.scope->data(), static_cast<long>(er.scope->size())));
         }
         if (er.collection) {
-            rb_hash_aset(
-              role, rb_id2sym(rb_intern("collection")), rb_str_new(er.collection->data(), static_cast<long>(er.collection->size())));
+            rb_hash_aset(role,
+                         rb_id2sym(rb_intern("collection")),
+                         rb_external_str_new(er.collection->data(), static_cast<long>(er.collection->size())));
         }
         rb_ary_push(roles, role);
     }
@@ -3687,8 +4087,8 @@ cb_Backend_user_get_all(VALUE self, VALUE domain, VALUE timeout)
         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");
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable to fetch users");
             break;
         }
 
@@ -3739,8 +4139,8 @@ cb_Backend_user_get(VALUE self, VALUE domain, VALUE username, VALUE timeout)
         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());
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, fmt::format(R"(unable to fetch user "{}")", req.username));
             break;
         }
 
@@ -3787,8 +4187,8 @@ cb_Backend_user_drop(VALUE self, VALUE domain, VALUE username, VALUE timeout)
         backend->cluster->execute_http(req,
                                        [barrier](couchbase::operations::user_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to fetch user "{}")", req.username).c_str());
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, fmt::format(R"(unable to fetch user "{}")", req.username));
             break;
         }
 
@@ -3883,9 +4283,9 @@ cb_Backend_user_upsert(VALUE self, VALUE domain, VALUE user, VALUE timeout)
         backend->cluster->execute_http(req,
                                        [barrier](couchbase::operations::user_upsert_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
-            exc = cb__map_error_code(
-              resp.ec, fmt::format(R"(unable to upsert user "{}" ({}))", req.user.username, fmt::join(resp.errors, ", ")).c_str());
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx,
+                                     fmt::format(R"(unable to upsert user "{}" ({}))", req.user.username, fmt::join(resp.errors, ", ")));
             break;
         }
 
@@ -3898,29 +4298,32 @@ cb_Backend_user_upsert(VALUE self, VALUE domain, VALUE user, VALUE timeout)
 static void
 cb__extract_group(const couchbase::operations::rbac::group& entry, VALUE group)
 {
-    rb_hash_aset(group, rb_id2sym(rb_intern("name")), rb_str_new(entry.name.data(), static_cast<long>(entry.name.size())));
+    rb_hash_aset(group, rb_id2sym(rb_intern("name")), rb_external_str_new(entry.name.data(), static_cast<long>(entry.name.size())));
     if (entry.description) {
-        rb_hash_aset(
-          group, rb_id2sym(rb_intern("description")), rb_str_new(entry.description->data(), static_cast<long>(entry.description->size())));
+        rb_hash_aset(group,
+                     rb_id2sym(rb_intern("description")),
+                     rb_external_str_new(entry.description->data(), static_cast<long>(entry.description->size())));
     }
     if (entry.ldap_group_reference) {
         rb_hash_aset(group,
                      rb_id2sym(rb_intern("ldap_group_reference")),
-                     rb_str_new(entry.ldap_group_reference->data(), static_cast<long>(entry.ldap_group_reference->size())));
+                     rb_external_str_new(entry.ldap_group_reference->data(), static_cast<long>(entry.ldap_group_reference->size())));
     }
     VALUE roles = rb_ary_new_capa(static_cast<long>(entry.roles.size()));
     for (const auto& er : entry.roles) {
         VALUE role = rb_hash_new();
-        rb_hash_aset(role, rb_id2sym(rb_intern("name")), rb_str_new(er.name.data(), static_cast<long>(er.name.size())));
+        rb_hash_aset(role, rb_id2sym(rb_intern("name")), rb_external_str_new(er.name.data(), static_cast<long>(er.name.size())));
         if (er.bucket) {
-            rb_hash_aset(role, rb_id2sym(rb_intern("bucket")), rb_str_new(er.bucket->data(), static_cast<long>(er.bucket->size())));
+            rb_hash_aset(
+              role, rb_id2sym(rb_intern("bucket")), rb_external_str_new(er.bucket->data(), static_cast<long>(er.bucket->size())));
         }
         if (er.scope) {
-            rb_hash_aset(role, rb_id2sym(rb_intern("scope")), rb_str_new(er.scope->data(), static_cast<long>(er.scope->size())));
+            rb_hash_aset(role, rb_id2sym(rb_intern("scope")), rb_external_str_new(er.scope->data(), static_cast<long>(er.scope->size())));
         }
         if (er.collection) {
-            rb_hash_aset(
-              role, rb_id2sym(rb_intern("collection")), rb_str_new(er.collection->data(), static_cast<long>(er.collection->size())));
+            rb_hash_aset(role,
+                         rb_id2sym(rb_intern("collection")),
+                         rb_external_str_new(er.collection->data(), static_cast<long>(er.collection->size())));
         }
         rb_ary_push(roles, role);
     }
@@ -3950,8 +4353,8 @@ cb_Backend_group_get_all(VALUE self, VALUE timeout)
         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");
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable to fetch groups");
             break;
         }
 
@@ -3993,8 +4396,8 @@ cb_Backend_group_get(VALUE self, VALUE name, VALUE timeout)
         backend->cluster->execute_http(req,
                                        [barrier](couchbase::operations::group_get_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to fetch group "{}")", req.name));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, fmt::format(R"(unable to fetch group "{}")", req.name));
             break;
         }
 
@@ -4032,8 +4435,8 @@ cb_Backend_group_drop(VALUE self, VALUE name, VALUE timeout)
         backend->cluster->execute_http(req,
                                        [barrier](couchbase::operations::group_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to drop group "{}")", req.name));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, fmt::format(R"(unable to drop group "{}")", req.name));
             break;
         }
 
@@ -4108,9 +4511,9 @@ cb_Backend_group_upsert(VALUE self, VALUE group, VALUE timeout)
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::group_upsert_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
-            exc = cb__map_error_code(
-              resp.ec, fmt::format(R"(unable to upsert group "{}" ({}))", req.group.name, fmt::join(resp.errors, ", ")).c_str());
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx,
+                                     fmt::format(R"(unable to upsert group "{}" ({}))", req.group.name, fmt::join(resp.errors, ", ")));
             break;
         }
 
@@ -4139,8 +4542,8 @@ cb_Backend_cluster_enable_developer_preview(VALUE self)
         backend->cluster->execute_http(
           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"));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable to enable developer preview for this cluster");
             break;
         }
         spdlog::critical(
@@ -4178,8 +4581,8 @@ cb_Backend_scope_get_all(VALUE self, VALUE bucket_name, VALUE timeout)
         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));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, fmt::format("unable to get list of the scopes of the bucket \"{}\"", req.bucket_name));
             break;
         }
 
@@ -4189,12 +4592,13 @@ cb_Backend_scope_get_all(VALUE self, VALUE bucket_name, VALUE timeout)
         for (const auto& s : resp.manifest.scopes) {
             VALUE scope = rb_hash_new();
             rb_hash_aset(scope, rb_id2sym(rb_intern("uid")), ULL2NUM(s.uid));
-            rb_hash_aset(scope, rb_id2sym(rb_intern("name")), rb_str_new(s.name.data(), static_cast<long>(s.name.size())));
+            rb_hash_aset(scope, rb_id2sym(rb_intern("name")), rb_external_str_new(s.name.data(), static_cast<long>(s.name.size())));
             VALUE collections = rb_ary_new_capa(static_cast<long>(s.collections.size()));
             for (const auto& c : s.collections) {
                 VALUE collection = rb_hash_new();
                 rb_hash_aset(collection, rb_id2sym(rb_intern("uid")), ULL2NUM(c.uid));
-                rb_hash_aset(collection, rb_id2sym(rb_intern("name")), rb_str_new(c.name.data(), static_cast<long>(c.name.size())));
+                rb_hash_aset(
+                  collection, rb_id2sym(rb_intern("name")), rb_external_str_new(c.name.data(), static_cast<long>(c.name.size())));
                 rb_ary_push(collections, collection);
             }
             rb_hash_aset(scope, rb_id2sym(rb_intern("collections")), collections);
@@ -4234,8 +4638,8 @@ cb_Backend_collections_manifest_get(VALUE self, VALUE bucket_name, VALUE timeout
         backend->cluster->execute(
           req, [barrier](couchbase::operations::collections_manifest_get_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, fmt::format("unable to get collections manifest of the bucket \"{}\"", req.id.bucket));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, fmt::format("unable to get collections manifest of the bucket \"{}\"", req.id.bucket));
             break;
         }
 
@@ -4245,12 +4649,13 @@ cb_Backend_collections_manifest_get(VALUE self, VALUE bucket_name, VALUE timeout
         for (const auto& s : resp.manifest.scopes) {
             VALUE scope = rb_hash_new();
             rb_hash_aset(scope, rb_id2sym(rb_intern("uid")), ULL2NUM(s.uid));
-            rb_hash_aset(scope, rb_id2sym(rb_intern("name")), rb_str_new(s.name.data(), static_cast<long>(s.name.size())));
+            rb_hash_aset(scope, rb_id2sym(rb_intern("name")), rb_external_str_new(s.name.data(), static_cast<long>(s.name.size())));
             VALUE collections = rb_ary_new_capa(static_cast<long>(s.collections.size()));
             for (const auto& c : s.collections) {
                 VALUE collection = rb_hash_new();
                 rb_hash_aset(collection, rb_id2sym(rb_intern("uid")), ULL2NUM(c.uid));
-                rb_hash_aset(collection, rb_id2sym(rb_intern("name")), rb_str_new(c.name.data(), static_cast<long>(c.name.size())));
+                rb_hash_aset(
+                  collection, rb_id2sym(rb_intern("name")), rb_external_str_new(c.name.data(), static_cast<long>(c.name.size())));
                 rb_ary_push(collections, collection);
             }
             rb_hash_aset(scope, rb_id2sym(rb_intern("collections")), collections);
@@ -4292,8 +4697,8 @@ cb_Backend_scope_create(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE t
         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,
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx,
                                      fmt::format(R"(unable to create the scope "{}" on the bucket "{}")", req.scope_name, req.bucket_name));
             break;
         }
@@ -4331,9 +4736,9 @@ cb_Backend_scope_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE tim
         backend->cluster->execute_http(req,
                                        [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,
-                                     fmt::format("unable to drop the scope \"{}\" on the bucket \"{}\"", req.scope_name, req.bucket_name));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx,
+                                     fmt::format(R"(unable to drop the scope "{}" on the bucket "{}")", req.scope_name, req.bucket_name));
             break;
         }
         return ULL2NUM(resp.uid);
@@ -4377,9 +4782,9 @@ cb_Backend_collection_create(VALUE self, VALUE bucket_name, VALUE scope_name, VA
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::collection_create_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             exc = cb__map_error_code(
-              resp.ec,
+              resp.ctx,
               fmt::format(
                 R"(unable create the collection "{}.{}" on the bucket "{}")", req.scope_name, req.collection_name, req.bucket_name));
             break;
@@ -4421,9 +4826,9 @@ cb_Backend_collection_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALU
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::collection_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             exc = cb__map_error_code(
-              resp.ec,
+              resp.ctx,
               fmt::format(
                 R"(unable to drop the collection  "{}.{}" on the bucket "{}")", req.scope_name, req.collection_name, req.bucket_name));
             break;
@@ -4460,43 +4865,49 @@ cb_Backend_query_index_get_all(VALUE self, VALUE bucket_name, VALUE timeout)
         backend->cluster->execute_http(
           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));
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, fmt::format("unable to get list of the indexes of the bucket \"{}\"", req.bucket_name));
             break;
         }
 
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_external_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
         VALUE indexes = rb_ary_new_capa(static_cast<long>(resp.indexes.size()));
         for (const auto& idx : resp.indexes) {
             VALUE index = rb_hash_new();
-            rb_hash_aset(index, rb_id2sym(rb_intern("id")), rb_str_new(idx.id.data(), static_cast<long>(idx.id.size())));
-            rb_hash_aset(index, rb_id2sym(rb_intern("state")), rb_str_new(idx.state.data(), static_cast<long>(idx.state.size())));
-            rb_hash_aset(index, rb_id2sym(rb_intern("name")), rb_str_new(idx.name.data(), static_cast<long>(idx.name.size())));
-            rb_hash_aset(
-              index, rb_id2sym(rb_intern("datastore_id")), rb_str_new(idx.datastore_id.data(), static_cast<long>(idx.datastore_id.size())));
-            rb_hash_aset(
-              index, rb_id2sym(rb_intern("keyspace_id")), rb_str_new(idx.keyspace_id.data(), static_cast<long>(idx.keyspace_id.size())));
-            rb_hash_aset(
-              index, rb_id2sym(rb_intern("namespace_id")), rb_str_new(idx.namespace_id.data(), static_cast<long>(idx.namespace_id.size())));
-            rb_hash_aset(index, rb_id2sym(rb_intern("type")), rb_str_new(idx.type.data(), static_cast<long>(idx.type.size())));
+            rb_hash_aset(index, rb_id2sym(rb_intern("id")), rb_external_str_new(idx.id.data(), static_cast<long>(idx.id.size())));
+            rb_hash_aset(index, rb_id2sym(rb_intern("state")), rb_external_str_new(idx.state.data(), static_cast<long>(idx.state.size())));
+            rb_hash_aset(index, rb_id2sym(rb_intern("name")), rb_external_str_new(idx.name.data(), static_cast<long>(idx.name.size())));
+            rb_hash_aset(index,
+                         rb_id2sym(rb_intern("datastore_id")),
+                         rb_external_str_new(idx.datastore_id.data(), static_cast<long>(idx.datastore_id.size())));
+            rb_hash_aset(index,
+                         rb_id2sym(rb_intern("keyspace_id")),
+                         rb_external_str_new(idx.keyspace_id.data(), static_cast<long>(idx.keyspace_id.size())));
+            rb_hash_aset(index,
+                         rb_id2sym(rb_intern("namespace_id")),
+                         rb_external_str_new(idx.namespace_id.data(), static_cast<long>(idx.namespace_id.size())));
+            rb_hash_aset(index, rb_id2sym(rb_intern("type")), rb_external_str_new(idx.type.data(), static_cast<long>(idx.type.size())));
             rb_hash_aset(index, rb_id2sym(rb_intern("is_primary")), idx.is_primary ? Qtrue : Qfalse);
             VALUE index_key = rb_ary_new_capa(static_cast<long>(idx.index_key.size()));
             for (const auto& key : idx.index_key) {
-                rb_ary_push(index_key, rb_str_new(key.data(), static_cast<long>(key.size())));
+                rb_ary_push(index_key, rb_external_str_new(key.data(), static_cast<long>(key.size())));
             }
             rb_hash_aset(index, rb_id2sym(rb_intern("index_key")), index_key);
             if (idx.scope_id) {
-                rb_hash_aset(
-                  index, rb_id2sym(rb_intern("scope_id")), rb_str_new(idx.scope_id->data(), static_cast<long>(idx.scope_id->size())));
+                rb_hash_aset(index,
+                             rb_id2sym(rb_intern("scope_id")),
+                             rb_external_str_new(idx.scope_id->data(), static_cast<long>(idx.scope_id->size())));
             }
             if (idx.bucket_id) {
-                rb_hash_aset(
-                  index, rb_id2sym(rb_intern("bucket_id")), rb_str_new(idx.bucket_id->data(), static_cast<long>(idx.bucket_id->size())));
+                rb_hash_aset(index,
+                             rb_id2sym(rb_intern("bucket_id")),
+                             rb_external_str_new(idx.bucket_id->data(), static_cast<long>(idx.bucket_id->size())));
             }
             if (idx.condition) {
-                rb_hash_aset(
-                  index, rb_id2sym(rb_intern("condition")), rb_str_new(idx.condition->data(), static_cast<long>(idx.condition->size())));
+                rb_hash_aset(index,
+                             rb_id2sym(rb_intern("condition")),
+                             rb_external_str_new(idx.condition->data(), static_cast<long>(idx.condition->size())));
             }
             rb_ary_push(indexes, index);
         }
@@ -4577,29 +4988,30 @@ cb_Backend_query_index_create(VALUE self, VALUE bucket_name, VALUE index_name, V
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::query_index_create_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (!resp.errors.empty()) {
                 const auto& first_error = resp.errors.front();
-                exc = cb__map_error_code(resp.ec,
+                exc = cb__map_error_code(resp.ctx,
                                          fmt::format(R"(unable to create index "{}" on the bucket "{}" ({}: {}))",
                                                      req.index_name,
                                                      req.bucket_name,
                                                      first_error.code,
                                                      first_error.message));
             } else {
-                exc = cb__map_error_code(resp.ec,
+                exc = cb__map_error_code(resp.ctx,
                                          fmt::format(R"(unable to create index "{}" on the bucket "{}")", req.index_name, req.bucket_name));
             }
             break;
         }
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_external_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
         if (!resp.errors.empty()) {
             VALUE errors = rb_ary_new_capa(static_cast<long>(resp.errors.size()));
             for (const auto& err : resp.errors) {
                 VALUE error = rb_hash_new();
                 rb_hash_aset(error, rb_id2sym(rb_intern("code")), ULL2NUM(err.code));
-                rb_hash_aset(error, rb_id2sym(rb_intern("message")), rb_str_new(err.message.data(), static_cast<long>(err.message.size())));
+                rb_hash_aset(
+                  error, rb_id2sym(rb_intern("message")), rb_external_str_new(err.message.data(), static_cast<long>(err.message.size())));
                 rb_ary_push(errors, error);
             }
             rb_hash_aset(res, rb_id2sym(rb_intern("errors")), errors);
@@ -4656,29 +5068,30 @@ cb_Backend_query_index_drop(VALUE self, VALUE bucket_name, VALUE index_name, VAL
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::query_index_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (!resp.errors.empty()) {
                 const auto& first_error = resp.errors.front();
-                exc = cb__map_error_code(resp.ec,
+                exc = cb__map_error_code(resp.ctx,
                                          fmt::format(R"(unable to drop index "{}" on the bucket "{}" ({}: {}))",
                                                      req.index_name,
                                                      req.bucket_name,
                                                      first_error.code,
                                                      first_error.message));
             } else {
-                exc = cb__map_error_code(resp.ec,
+                exc = cb__map_error_code(resp.ctx,
                                          fmt::format(R"(unable to drop index "{}" on the bucket "{}")", req.index_name, req.bucket_name));
             }
             break;
         }
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_external_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
         if (!resp.errors.empty()) {
             VALUE errors = rb_ary_new_capa(static_cast<long>(resp.errors.size()));
             for (const auto& err : resp.errors) {
                 VALUE error = rb_hash_new();
                 rb_hash_aset(error, rb_id2sym(rb_intern("code")), ULL2NUM(err.code));
-                rb_hash_aset(error, rb_id2sym(rb_intern("message")), rb_str_new(err.message.data(), static_cast<long>(err.message.size())));
+                rb_hash_aset(
+                  error, rb_id2sym(rb_intern("message")), rb_external_str_new(err.message.data(), static_cast<long>(err.message.size())));
                 rb_ary_push(errors, error);
             }
             rb_hash_aset(res, rb_id2sym(rb_intern("errors")), errors);
@@ -4751,28 +5164,29 @@ cb_Backend_query_index_create_primary(VALUE self, VALUE bucket_name, VALUE optio
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::query_index_create_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (!resp.errors.empty()) {
                 const auto& first_error = resp.errors.front();
-                exc = cb__map_error_code(resp.ec,
+                exc = cb__map_error_code(resp.ctx,
                                          fmt::format(R"(unable to create primary index on the bucket "{}" ({}: {}))",
                                                      req.bucket_name,
                                                      first_error.code,
                                                      first_error.message));
             } else {
                 exc = cb__map_error_code(
-                  resp.ec, fmt::format(R"(unable to create primary index on the bucket "{}")", req.index_name, req.bucket_name));
+                  resp.ctx, fmt::format(R"(unable to create primary index on the bucket "{}")", req.index_name, req.bucket_name));
             }
             break;
         }
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_external_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
         if (!resp.errors.empty()) {
             VALUE errors = rb_ary_new_capa(static_cast<long>(resp.errors.size()));
             for (const auto& err : resp.errors) {
                 VALUE error = rb_hash_new();
                 rb_hash_aset(error, rb_id2sym(rb_intern("code")), ULL2NUM(err.code));
-                rb_hash_aset(error, rb_id2sym(rb_intern("message")), rb_str_new(err.message.data(), static_cast<long>(err.message.size())));
+                rb_hash_aset(
+                  error, rb_id2sym(rb_intern("message")), rb_external_str_new(err.message.data(), static_cast<long>(err.message.size())));
                 rb_ary_push(errors, error);
             }
             rb_hash_aset(res, rb_id2sym(rb_intern("errors")), errors);
@@ -4834,26 +5248,27 @@ cb_Backend_query_index_drop_primary(VALUE self, VALUE bucket_name, VALUE options
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::query_index_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (!resp.errors.empty()) {
                 const auto& first_error = resp.errors.front();
                 exc = cb__map_error_code(
-                  resp.ec,
+                  resp.ctx,
                   fmt::format(
                     R"(unable to drop primary index on the bucket "{}" ({}: {}))", req.bucket_name, first_error.code, first_error.message));
             } else {
-                exc = cb__map_error_code(resp.ec, fmt::format(R"(unable to drop primary index on the bucket "{}")", req.bucket_name));
+                exc = cb__map_error_code(resp.ctx, fmt::format(R"(unable to drop primary index on the bucket "{}")", req.bucket_name));
             }
             break;
         }
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_external_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
         if (!resp.errors.empty()) {
             VALUE errors = rb_ary_new_capa(static_cast<long>(resp.errors.size()));
             for (const auto& err : resp.errors) {
                 VALUE error = rb_hash_new();
                 rb_hash_aset(error, rb_id2sym(rb_intern("code")), ULL2NUM(err.code));
-                rb_hash_aset(error, rb_id2sym(rb_intern("message")), rb_str_new(err.message.data(), static_cast<long>(err.message.size())));
+                rb_hash_aset(
+                  error, rb_id2sym(rb_intern("message")), rb_external_str_new(err.message.data(), static_cast<long>(err.message.size())));
                 rb_ary_push(errors, error);
             }
             rb_hash_aset(res, rb_id2sym(rb_intern("errors")), errors);
@@ -4890,17 +5305,17 @@ cb_Backend_query_index_build_deferred(VALUE self, VALUE bucket_name, VALUE timeo
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::query_index_build_deferred_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (!resp.errors.empty()) {
                 const auto& first_error = resp.errors.front();
                 exc = cb__map_error_code(
-                  resp.ec,
+                  resp.ctx,
                   fmt::format(
                     R"(unable to drop primary index on the bucket "{}" ({}: {}))", req.bucket_name, first_error.code, first_error.message));
 
             } else {
                 exc = cb__map_error_code(
-                  resp.ec, fmt::format("unable to trigger build for deferred indexes for the bucket \"{}\"", req.bucket_name));
+                  resp.ctx, fmt::format("unable to trigger build for deferred indexes for the bucket \"{}\"", req.bucket_name));
             }
             break;
         }
@@ -4934,31 +5349,35 @@ cb_Backend_query_index_watch(VALUE self, VALUE bucket_name, VALUE index_names, V
 static void
 cb__extract_search_index(VALUE index, const couchbase::operations::search_index& idx)
 {
-    rb_hash_aset(index, rb_id2sym(rb_intern("uuid")), rb_str_new(idx.uuid.data(), static_cast<long>(idx.uuid.size())));
-    rb_hash_aset(index, rb_id2sym(rb_intern("name")), rb_str_new(idx.name.data(), static_cast<long>(idx.name.size())));
-    rb_hash_aset(index, rb_id2sym(rb_intern("type")), rb_str_new(idx.type.data(), static_cast<long>(idx.type.size())));
+    rb_hash_aset(index, rb_id2sym(rb_intern("uuid")), rb_external_str_new(idx.uuid.data(), static_cast<long>(idx.uuid.size())));
+    rb_hash_aset(index, rb_id2sym(rb_intern("name")), rb_external_str_new(idx.name.data(), static_cast<long>(idx.name.size())));
+    rb_hash_aset(index, rb_id2sym(rb_intern("type")), rb_external_str_new(idx.type.data(), static_cast<long>(idx.type.size())));
     if (!idx.params_json.empty()) {
-        rb_hash_aset(index, rb_id2sym(rb_intern("params")), rb_str_new(idx.params_json.data(), static_cast<long>(idx.params_json.size())));
+        rb_hash_aset(
+          index, rb_id2sym(rb_intern("params")), rb_external_str_new(idx.params_json.data(), static_cast<long>(idx.params_json.size())));
     }
 
     if (!idx.source_uuid.empty()) {
-        rb_hash_aset(
-          index, rb_id2sym(rb_intern("source_uuid")), rb_str_new(idx.source_uuid.data(), static_cast<long>(idx.source_uuid.size())));
+        rb_hash_aset(index,
+                     rb_id2sym(rb_intern("source_uuid")),
+                     rb_external_str_new(idx.source_uuid.data(), static_cast<long>(idx.source_uuid.size())));
     }
     if (!idx.source_name.empty()) {
-        rb_hash_aset(
-          index, rb_id2sym(rb_intern("source_name")), rb_str_new(idx.source_name.data(), static_cast<long>(idx.source_name.size())));
+        rb_hash_aset(index,
+                     rb_id2sym(rb_intern("source_name")),
+                     rb_external_str_new(idx.source_name.data(), static_cast<long>(idx.source_name.size())));
     }
-    rb_hash_aset(index, rb_id2sym(rb_intern("source_type")), rb_str_new(idx.source_type.data(), static_cast<long>(idx.source_type.size())));
+    rb_hash_aset(
+      index, rb_id2sym(rb_intern("source_type")), rb_external_str_new(idx.source_type.data(), static_cast<long>(idx.source_type.size())));
     if (!idx.source_params_json.empty()) {
         rb_hash_aset(index,
                      rb_id2sym(rb_intern("source_params")),
-                     rb_str_new(idx.source_params_json.data(), static_cast<long>(idx.source_params_json.size())));
+                     rb_external_str_new(idx.source_params_json.data(), static_cast<long>(idx.source_params_json.size())));
     }
     if (!idx.plan_params_json.empty()) {
         rb_hash_aset(index,
                      rb_id2sym(rb_intern("plan_params")),
-                     rb_str_new(idx.plan_params_json.data(), static_cast<long>(idx.plan_params_json.size())));
+                     rb_external_str_new(idx.plan_params_json.data(), static_cast<long>(idx.plan_params_json.size())));
     }
 }
 
@@ -4985,14 +5404,15 @@ cb_Backend_search_index_get_all(VALUE self, VALUE timeout)
         backend->cluster->execute_http(
           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");
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable to get list of the search indexes");
             break;
         }
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
-        rb_hash_aset(
-          res, rb_id2sym(rb_intern("impl_version")), rb_str_new(resp.impl_version.data(), static_cast<long>(resp.impl_version.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_external_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        rb_hash_aset(res,
+                     rb_id2sym(rb_intern("impl_version")),
+                     rb_external_str_new(resp.impl_version.data(), static_cast<long>(resp.impl_version.size())));
         VALUE indexes = rb_ary_new_capa(static_cast<long>(resp.indexes.size()));
         for (const auto& idx : resp.indexes) {
             VALUE index = rb_hash_new();
@@ -5031,11 +5451,11 @@ cb_Backend_search_index_get(VALUE self, VALUE index_name, VALUE timeout)
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::search_index_get_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.error.empty()) {
-                exc = cb__map_error_code(resp.ec, fmt::format("unable to get search index \"{}\"", req.index_name));
+                exc = cb__map_error_code(resp.ctx, fmt::format("unable to get search index \"{}\"", req.index_name));
             } else {
-                exc = cb__map_error_code(resp.ec, fmt::format("unable to get search index \"{}\": {}", req.index_name, resp.error));
+                exc = cb__map_error_code(resp.ctx, fmt::format("unable to get search index \"{}\": {}", req.index_name, resp.error));
             }
             break;
         }
@@ -5120,16 +5540,16 @@ cb_Backend_search_index_upsert(VALUE self, VALUE index_definition, VALUE timeout
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::search_index_upsert_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.error.empty()) {
-                exc = cb__map_error_code(resp.ec, fmt::format("unable to upsert the search index \"{}\"", req.index.name));
+                exc = cb__map_error_code(resp.ctx, fmt::format("unable to upsert the search index \"{}\"", req.index.name));
             } else {
-                exc = cb__map_error_code(resp.ec, fmt::format("unable to upsert the search index \"{}\": {}", req.index.name, resp.error));
+                exc = cb__map_error_code(resp.ctx, fmt::format("unable to upsert the search index \"{}\": {}", req.index.name, resp.error));
             }
             break;
         }
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_external_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
         return res;
     } while (false);
     rb_exc_raise(exc);
@@ -5161,16 +5581,16 @@ cb_Backend_search_index_drop(VALUE self, VALUE index_name, VALUE timeout)
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::search_index_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.error.empty()) {
-                exc = cb__map_error_code(resp.ec, fmt::format("unable to drop the search index \"{}\"", req.index_name));
+                exc = cb__map_error_code(resp.ctx, fmt::format("unable to drop the search index \"{}\"", req.index_name));
             } else {
-                exc = cb__map_error_code(resp.ec, fmt::format("unable to drop the search index \"{}\": {}", req.index_name, resp.error));
+                exc = cb__map_error_code(resp.ctx, fmt::format("unable to drop the search index \"{}\": {}", req.index_name, resp.error));
             }
             break;
         }
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_external_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
         return res;
     } while (false);
     rb_exc_raise(exc);
@@ -5202,19 +5622,19 @@ cb_Backend_search_index_get_documents_count(VALUE self, VALUE index_name, VALUE
         backend->cluster->execute_http(
           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.ctx.ec) {
             if (resp.error.empty()) {
                 exc = cb__map_error_code(
-                  resp.ec, fmt::format("unable to get number of the indexed documents for the search index \"{}\"", req.index_name));
+                  resp.ctx, fmt::format("unable to get number of the indexed documents for the search index \"{}\"", req.index_name));
             } else {
                 exc = cb__map_error_code(
-                  resp.ec,
+                  resp.ctx,
                   fmt::format("unable to get number of the indexed documents for the search index \"{}\": {}", req.index_name, resp.error));
             }
             break;
         }
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_external_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
         rb_hash_aset(res, rb_id2sym(rb_intern("count")), ULL2NUM(resp.count));
         return res;
     } while (false);
@@ -5247,16 +5667,16 @@ cb_Backend_search_index_get_stats(VALUE self, VALUE index_name, VALUE timeout)
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::search_index_get_stats_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.error.empty()) {
-                exc = cb__map_error_code(resp.ec, fmt::format("unable to get stats for the search index \"{}\"", req.index_name));
+                exc = cb__map_error_code(resp.ctx, fmt::format("unable to get stats for the search index \"{}\"", req.index_name));
             } else {
-                exc = cb__map_error_code(resp.ec,
+                exc = cb__map_error_code(resp.ctx,
                                          fmt::format("unable to get stats for the search index \"{}\": {}", req.index_name, resp.error));
             }
             break;
         }
-        return rb_str_new(resp.stats.data(), static_cast<long>(resp.stats.size()));
+        return rb_external_str_new(resp.stats.data(), static_cast<long>(resp.stats.size()));
     } while (false);
     rb_exc_raise(exc);
     return Qnil;
@@ -5285,11 +5705,11 @@ cb_Backend_search_get_stats(VALUE self, VALUE timeout)
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::search_index_stats_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
-            exc = cb__map_error_code(resp.ec, "unable to get stats for the search service");
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable to get stats for the search service");
             break;
         }
-        return rb_str_new(resp.stats.data(), static_cast<long>(resp.stats.size()));
+        return rb_external_str_new(resp.stats.data(), static_cast<long>(resp.stats.size()));
     } while (false);
     rb_exc_raise(exc);
     return Qnil;
@@ -5321,17 +5741,17 @@ cb_Backend_search_index_pause_ingest(VALUE self, VALUE index_name, VALUE timeout
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::search_index_control_ingest_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.error.empty()) {
-                exc = cb__map_error_code(resp.ec, fmt::format("unable to pause ingest for the search index \"{}\"", req.index_name));
+                exc = cb__map_error_code(resp.ctx, fmt::format("unable to pause ingest for the search index \"{}\"", req.index_name));
             } else {
-                exc = cb__map_error_code(resp.ec,
+                exc = cb__map_error_code(resp.ctx,
                                          fmt::format("unable to pause ingest for the search index \"{}\": {}", req.index_name, resp.error));
             }
             break;
         }
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_external_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
         return res;
     } while (false);
     rb_exc_raise(exc);
@@ -5364,17 +5784,17 @@ cb_Backend_search_index_resume_ingest(VALUE self, VALUE index_name, VALUE timeou
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::search_index_control_ingest_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.error.empty()) {
-                exc = cb__map_error_code(resp.ec, fmt::format("unable to resume ingest for the search index \"{}\"", req.index_name));
+                exc = cb__map_error_code(resp.ctx, fmt::format("unable to resume ingest for the search index \"{}\"", req.index_name));
             } else {
                 exc = cb__map_error_code(
-                  resp.ec, fmt::format("unable to resume ingest for the search index \"{}\": {}", req.index_name, resp.error));
+                  resp.ctx, fmt::format("unable to resume ingest for the search index \"{}\": {}", req.index_name, resp.error));
             }
             break;
         }
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_external_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
         return res;
     } while (false);
     rb_exc_raise(exc);
@@ -5407,17 +5827,17 @@ cb_Backend_search_index_allow_querying(VALUE self, VALUE index_name, VALUE timeo
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::search_index_control_query_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.error.empty()) {
-                exc = cb__map_error_code(resp.ec, fmt::format("unable to allow querying for the search index \"{}\"", req.index_name));
+                exc = cb__map_error_code(resp.ctx, fmt::format("unable to allow querying for the search index \"{}\"", req.index_name));
             } else {
                 exc = cb__map_error_code(
-                  resp.ec, fmt::format("unable to allow querying for the search index \"{}\": {}", req.index_name, resp.error));
+                  resp.ctx, fmt::format("unable to allow querying for the search index \"{}\": {}", req.index_name, resp.error));
             }
             break;
         }
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_external_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
         return res;
     } while (false);
     rb_exc_raise(exc);
@@ -5450,17 +5870,17 @@ cb_Backend_search_index_disallow_querying(VALUE self, VALUE index_name, VALUE ti
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::search_index_control_query_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.error.empty()) {
-                exc = cb__map_error_code(resp.ec, fmt::format("unable to disallow querying for the search index \"{}\"", req.index_name));
+                exc = cb__map_error_code(resp.ctx, fmt::format("unable to disallow querying for the search index \"{}\"", req.index_name));
             } else {
                 exc = cb__map_error_code(
-                  resp.ec, fmt::format("unable to disallow querying for the search index \"{}\": {}", req.index_name, resp.error));
+                  resp.ctx, fmt::format("unable to disallow querying for the search index \"{}\": {}", req.index_name, resp.error));
             }
             break;
         }
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_external_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
         return res;
     } while (false);
     rb_exc_raise(exc);
@@ -5493,17 +5913,17 @@ cb_Backend_search_index_freeze_plan(VALUE self, VALUE index_name, VALUE timeout)
         backend->cluster->execute_http(
           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.ctx.ec) {
             if (resp.error.empty()) {
-                exc = cb__map_error_code(resp.ec, fmt::format("unable to freeze for the search index \"{}\"", req.index_name));
+                exc = cb__map_error_code(resp.ctx, fmt::format("unable to freeze for the search index \"{}\"", req.index_name));
             } else {
                 exc =
-                  cb__map_error_code(resp.ec, fmt::format("unable to freeze for the search index \"{}\": {}", req.index_name, resp.error));
+                  cb__map_error_code(resp.ctx, fmt::format("unable to freeze for the search index \"{}\": {}", req.index_name, resp.error));
             }
             break;
         }
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_external_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
         return res;
     } while (false);
     rb_exc_raise(exc);
@@ -5536,17 +5956,17 @@ cb_Backend_search_index_unfreeze_plan(VALUE self, VALUE index_name, VALUE timeou
         backend->cluster->execute_http(
           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.ctx.ec) {
             if (resp.error.empty()) {
-                exc = cb__map_error_code(resp.ec, fmt::format("unable to unfreeze plan for the search index \"{}\"", req.index_name));
+                exc = cb__map_error_code(resp.ctx, fmt::format("unable to unfreeze plan for the search index \"{}\"", req.index_name));
             } else {
-                exc = cb__map_error_code(resp.ec,
+                exc = cb__map_error_code(resp.ctx,
                                          fmt::format("unable to unfreeze for the search index \"{}\": {}", req.index_name, resp.error));
             }
             break;
         }
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_external_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
         return res;
     } while (false);
     rb_exc_raise(exc);
@@ -5582,18 +6002,19 @@ cb_Backend_search_index_analyze_document(VALUE self, VALUE index_name, VALUE enc
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::search_index_analyze_document_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.error.empty()) {
-                exc = cb__map_error_code(resp.ec, fmt::format("unable to analyze document using the search index \"{}\"", req.index_name));
+                exc = cb__map_error_code(resp.ctx, fmt::format("unable to analyze document using the search index \"{}\"", req.index_name));
             } else {
                 exc = cb__map_error_code(
-                  resp.ec, fmt::format("unable to analyze document using the search index \"{}\": {}", req.index_name, resp.error));
+                  resp.ctx, fmt::format("unable to analyze document using the search index \"{}\": {}", req.index_name, resp.error));
             }
             break;
         }
         VALUE res = rb_hash_new();
-        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
-        rb_hash_aset(res, rb_id2sym(rb_intern("analysis")), rb_str_new(resp.analysis.data(), static_cast<long>(resp.analysis.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), rb_external_str_new(resp.status.data(), static_cast<long>(resp.status.size())));
+        rb_hash_aset(
+          res, rb_id2sym(rb_intern("analysis")), rb_external_str_new(resp.analysis.data(), static_cast<long>(resp.analysis.size())));
         return res;
     } while (false);
     rb_exc_raise(exc);
@@ -5768,22 +6189,23 @@ cb_Backend_document_search(VALUE self, VALUE index_name, VALUE query, VALUE opti
         auto f = barrier->get_future();
         backend->cluster->execute_http(req, [barrier](couchbase::operations::search_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             exc =
-              cb__map_error_code(resp.ec, fmt::format("unable to perform search query for index \"{}\": {}", req.index_name, resp.error));
+              cb__map_error_code(resp.ctx, fmt::format("unable to perform search query for index \"{}\": {}", req.index_name, resp.error));
             break;
         }
         VALUE res = rb_hash_new();
 
         VALUE meta_data = rb_hash_new();
-        rb_hash_aset(meta_data,
-                     rb_id2sym(rb_intern("client_context_id")),
-                     rb_str_new(resp.meta_data.client_context_id.data(), static_cast<long>(resp.meta_data.client_context_id.size())));
+        rb_hash_aset(
+          meta_data,
+          rb_id2sym(rb_intern("client_context_id")),
+          rb_external_str_new(resp.meta_data.client_context_id.data(), static_cast<long>(resp.meta_data.client_context_id.size())));
 
         VALUE metrics = rb_hash_new();
         rb_hash_aset(metrics,
                      rb_id2sym(rb_intern("took")),
-                     LONG2NUM(std::chrono::duration_cast<std::chrono::milliseconds>(resp.meta_data.metrics.took).count()));
+                     LL2NUM(std::chrono::duration_cast<std::chrono::milliseconds>(resp.meta_data.metrics.took).count()));
         rb_hash_aset(metrics, rb_id2sym(rb_intern("total_rows")), ULL2NUM(resp.meta_data.metrics.total_rows));
         rb_hash_aset(metrics, rb_id2sym(rb_intern("max_score")), DBL2NUM(resp.meta_data.metrics.max_score));
         rb_hash_aset(metrics, rb_id2sym(rb_intern("success_partition_count")), ULL2NUM(resp.meta_data.metrics.success_partition_count));
@@ -5794,8 +6216,8 @@ cb_Backend_document_search(VALUE self, VALUE index_name, VALUE query, VALUE opti
             VALUE errors = rb_hash_new();
             for (auto err : resp.meta_data.errors) {
                 rb_hash_aset(errors,
-                             rb_str_new(err.first.data(), static_cast<long>(err.first.size())),
-                             rb_str_new(err.second.data(), static_cast<long>(err.second.size())));
+                             rb_external_str_new(err.first.data(), static_cast<long>(err.first.size())),
+                             rb_external_str_new(err.second.data(), static_cast<long>(err.second.size())));
             }
             rb_hash_aset(meta_data, rb_id2sym(rb_intern("errors")), errors);
         }
@@ -5805,14 +6227,16 @@ cb_Backend_document_search(VALUE self, VALUE index_name, VALUE query, VALUE opti
         VALUE rows = rb_ary_new_capa(static_cast<long>(resp.rows.size()));
         for (const auto& entry : resp.rows) {
             VALUE row = rb_hash_new();
-            rb_hash_aset(row, rb_id2sym(rb_intern("index")), rb_str_new(entry.index.data(), static_cast<long>(entry.index.size())));
-            rb_hash_aset(row, rb_id2sym(rb_intern("id")), rb_str_new(entry.id.data(), static_cast<long>(entry.id.size())));
+            rb_hash_aset(
+              row, rb_id2sym(rb_intern("index")), rb_external_str_new(entry.index.data(), static_cast<long>(entry.index.size())));
+            rb_hash_aset(row, rb_id2sym(rb_intern("id")), rb_external_str_new(entry.id.data(), static_cast<long>(entry.id.size())));
             rb_hash_aset(row, rb_id2sym(rb_intern("score")), DBL2NUM(entry.score));
             VALUE locations = rb_ary_new_capa(static_cast<long>(entry.locations.size()));
             for (const auto& loc : entry.locations) {
                 VALUE location = rb_hash_new();
-                rb_hash_aset(row, rb_id2sym(rb_intern("field")), rb_str_new(loc.field.data(), static_cast<long>(loc.field.size())));
-                rb_hash_aset(row, rb_id2sym(rb_intern("term")), rb_str_new(loc.term.data(), static_cast<long>(loc.term.size())));
+                rb_hash_aset(
+                  row, rb_id2sym(rb_intern("field")), rb_external_str_new(loc.field.data(), static_cast<long>(loc.field.size())));
+                rb_hash_aset(row, rb_id2sym(rb_intern("term")), rb_external_str_new(loc.term.data(), static_cast<long>(loc.term.size())));
                 rb_hash_aset(row, rb_id2sym(rb_intern("pos")), ULL2NUM(loc.position));
                 rb_hash_aset(row, rb_id2sym(rb_intern("start_offset")), ULL2NUM(loc.start_offset));
                 rb_hash_aset(row, rb_id2sym(rb_intern("end_offset")), ULL2NUM(loc.end_offset));
@@ -5831,20 +6255,22 @@ cb_Backend_document_search(VALUE self, VALUE index_name, VALUE query, VALUE opti
                 for (const auto& field_fragments : entry.fragments) {
                     VALUE fragments_list = rb_ary_new_capa(static_cast<long>(field_fragments.second.size()));
                     for (const auto& fragment : field_fragments.second) {
-                        rb_ary_push(fragments_list, rb_str_new(fragment.data(), static_cast<long>(fragment.size())));
+                        rb_ary_push(fragments_list, rb_external_str_new(fragment.data(), static_cast<long>(fragment.size())));
                     }
-                    rb_hash_aset(
-                      fragments, rb_str_new(field_fragments.first.data(), static_cast<long>(field_fragments.first.size())), fragments_list);
+                    rb_hash_aset(fragments,
+                                 rb_external_str_new(field_fragments.first.data(), static_cast<long>(field_fragments.first.size())),
+                                 fragments_list);
                 }
                 rb_hash_aset(row, rb_id2sym(rb_intern("fragments")), fragments);
             }
             if (!entry.fields.empty()) {
-                rb_hash_aset(row, rb_id2sym(rb_intern("fields")), rb_str_new(entry.fields.data(), static_cast<long>(entry.fields.size())));
+                rb_hash_aset(
+                  row, rb_id2sym(rb_intern("fields")), rb_external_str_new(entry.fields.data(), static_cast<long>(entry.fields.size())));
             }
             if (!entry.explanation.empty()) {
                 rb_hash_aset(row,
                              rb_id2sym(rb_intern("explanation")),
-                             rb_str_new(entry.explanation.data(), static_cast<long>(entry.explanation.size())));
+                             rb_external_str_new(entry.explanation.data(), static_cast<long>(entry.explanation.size())));
             }
             rb_ary_push(rows, row);
         }
@@ -5854,9 +6280,10 @@ cb_Backend_document_search(VALUE self, VALUE index_name, VALUE query, VALUE opti
             VALUE result_facets = rb_hash_new();
             for (const auto& entry : resp.facets) {
                 VALUE facet = rb_hash_new();
-                VALUE facet_name = rb_str_new(entry.name.data(), static_cast<long>(entry.name.size()));
+                VALUE facet_name = rb_external_str_new(entry.name.data(), static_cast<long>(entry.name.size()));
                 rb_hash_aset(facet, rb_id2sym(rb_intern("name")), facet_name);
-                rb_hash_aset(facet, rb_id2sym(rb_intern("field")), rb_str_new(entry.field.data(), static_cast<long>(entry.field.size())));
+                rb_hash_aset(
+                  facet, rb_id2sym(rb_intern("field")), rb_external_str_new(entry.field.data(), static_cast<long>(entry.field.size())));
                 rb_hash_aset(facet, rb_id2sym(rb_intern("total")), ULL2NUM(entry.total));
                 rb_hash_aset(facet, rb_id2sym(rb_intern("missing")), ULL2NUM(entry.missing));
                 rb_hash_aset(facet, rb_id2sym(rb_intern("other")), ULL2NUM(entry.other));
@@ -5864,7 +6291,8 @@ cb_Backend_document_search(VALUE self, VALUE index_name, VALUE query, VALUE opti
                     VALUE terms = rb_ary_new_capa(static_cast<long>(entry.terms.size()));
                     for (const auto& item : entry.terms) {
                         VALUE term = rb_hash_new();
-                        rb_hash_aset(term, rb_id2sym(rb_intern("term")), rb_str_new(item.term.data(), static_cast<long>(item.term.size())));
+                        rb_hash_aset(
+                          term, rb_id2sym(rb_intern("term")), rb_external_str_new(item.term.data(), static_cast<long>(item.term.size())));
                         rb_hash_aset(term, rb_id2sym(rb_intern("count")), ULL2NUM(item.count));
                         rb_ary_push(terms, term);
                     }
@@ -5873,18 +6301,19 @@ cb_Backend_document_search(VALUE self, VALUE index_name, VALUE query, VALUE opti
                     VALUE date_ranges = rb_ary_new_capa(static_cast<long>(entry.date_ranges.size()));
                     for (const auto& item : entry.date_ranges) {
                         VALUE date_range = rb_hash_new();
-                        rb_hash_aset(
-                          date_range, rb_id2sym(rb_intern("name")), rb_str_new(item.name.data(), static_cast<long>(item.name.size())));
+                        rb_hash_aset(date_range,
+                                     rb_id2sym(rb_intern("name")),
+                                     rb_external_str_new(item.name.data(), static_cast<long>(item.name.size())));
                         rb_hash_aset(date_range, rb_id2sym(rb_intern("count")), ULL2NUM(item.count));
                         if (item.start) {
                             rb_hash_aset(date_range,
                                          rb_id2sym(rb_intern("start_time")),
-                                         rb_str_new(item.start->data(), static_cast<long>(item.start->size())));
+                                         rb_external_str_new(item.start->data(), static_cast<long>(item.start->size())));
                         }
                         if (item.end) {
                             rb_hash_aset(date_range,
                                          rb_id2sym(rb_intern("end_time")),
-                                         rb_str_new(item.end->data(), static_cast<long>(item.end->size())));
+                                         rb_external_str_new(item.end->data(), static_cast<long>(item.end->size())));
                         }
                         rb_ary_push(date_ranges, date_range);
                     }
@@ -5893,8 +6322,9 @@ cb_Backend_document_search(VALUE self, VALUE index_name, VALUE query, VALUE opti
                     VALUE numeric_ranges = rb_ary_new_capa(static_cast<long>(entry.numeric_ranges.size()));
                     for (const auto& item : entry.numeric_ranges) {
                         VALUE numeric_range = rb_hash_new();
-                        rb_hash_aset(
-                          numeric_range, rb_id2sym(rb_intern("name")), rb_str_new(item.name.data(), static_cast<long>(item.name.size())));
+                        rb_hash_aset(numeric_range,
+                                     rb_id2sym(rb_intern("name")),
+                                     rb_external_str_new(item.name.data(), static_cast<long>(item.name.size())));
                         rb_hash_aset(numeric_range, rb_id2sym(rb_intern("count")), ULL2NUM(item.count));
                         if (std::holds_alternative<double>(item.min)) {
                             rb_hash_aset(numeric_range, rb_id2sym(rb_intern("min")), DBL2NUM(std::get<double>(item.min)));
@@ -5964,8 +6394,9 @@ cb_Backend_dns_srv(VALUE self, VALUE hostname, VALUE service)
         VALUE res = rb_ary_new();
         for (const auto& target : resp.targets) {
             VALUE addr = rb_hash_new();
-            rb_hash_aset(
-              addr, rb_id2sym(rb_intern("hostname")), rb_str_new(target.hostname.data(), static_cast<long>(target.hostname.size())));
+            rb_hash_aset(addr,
+                         rb_id2sym(rb_intern("hostname")),
+                         rb_external_str_new(target.hostname.data(), static_cast<long>(target.hostname.size())));
             rb_hash_aset(addr, rb_id2sym(rb_intern("port")), UINT2NUM(target.port));
             rb_ary_push(res, addr);
         }
@@ -5998,20 +6429,20 @@ cb_Backend_analytics_get_pending_mutations(VALUE self, VALUE timeout)
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::analytics_get_pending_mutations_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.errors.empty()) {
-                exc = cb__map_error_code(resp.ec, "unable to get pending mutations for the analytics service");
+                exc = cb__map_error_code(resp.ctx, "unable to get pending mutations for the analytics service");
             } else {
                 const auto& first_error = resp.errors.front();
                 exc = cb__map_error_code(
-                  resp.ec,
+                  resp.ctx,
                   fmt::format("unable to get pending mutations for the analytics service ({}: {})", first_error.code, first_error.message));
             }
             break;
         }
         VALUE res = rb_hash_new();
         for (const auto& entry : resp.stats) {
-            rb_hash_aset(res, rb_str_new(entry.first.data(), static_cast<long>(entry.first.size())), ULL2NUM(entry.second));
+            rb_hash_aset(res, rb_external_str_new(entry.first.data(), static_cast<long>(entry.first.size())), ULL2NUM(entry.second));
         }
         return res;
     } while (false);
@@ -6042,27 +6473,28 @@ cb_Backend_analytics_dataset_get_all(VALUE self, VALUE timeout)
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::analytics_dataset_get_all_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.errors.empty()) {
-                exc = cb__map_error_code(resp.ec, "unable to fetch all datasets");
+                exc = cb__map_error_code(resp.ctx, "unable to fetch all datasets");
             } else {
                 const auto& first_error = resp.errors.front();
                 exc =
-                  cb__map_error_code(resp.ec, fmt::format("unable to fetch all datasets ({}: {})", first_error.code, first_error.message));
+                  cb__map_error_code(resp.ctx, fmt::format("unable to fetch all datasets ({}: {})", first_error.code, first_error.message));
             }
             break;
         }
         VALUE res = rb_ary_new_capa(static_cast<long>(resp.datasets.size()));
         for (const auto& ds : resp.datasets) {
             VALUE dataset = rb_hash_new();
-            rb_hash_aset(dataset, rb_id2sym(rb_intern("name")), rb_str_new(ds.name.data(), static_cast<long>(ds.name.size())));
+            rb_hash_aset(dataset, rb_id2sym(rb_intern("name")), rb_external_str_new(ds.name.data(), static_cast<long>(ds.name.size())));
             rb_hash_aset(dataset,
                          rb_id2sym(rb_intern("dataverse_name")),
-                         rb_str_new(ds.dataverse_name.data(), static_cast<long>(ds.dataverse_name.size())));
-            rb_hash_aset(
-              dataset, rb_id2sym(rb_intern("link_name")), rb_str_new(ds.link_name.data(), static_cast<long>(ds.link_name.size())));
+                         rb_external_str_new(ds.dataverse_name.data(), static_cast<long>(ds.dataverse_name.size())));
             rb_hash_aset(
-              dataset, rb_id2sym(rb_intern("bucket_name")), rb_str_new(ds.bucket_name.data(), static_cast<long>(ds.bucket_name.size())));
+              dataset, rb_id2sym(rb_intern("link_name")), rb_external_str_new(ds.link_name.data(), static_cast<long>(ds.link_name.size())));
+            rb_hash_aset(dataset,
+                         rb_id2sym(rb_intern("bucket_name")),
+                         rb_external_str_new(ds.bucket_name.data(), static_cast<long>(ds.bucket_name.size())));
             rb_ary_push(res, dataset);
         }
         return res;
@@ -6106,12 +6538,12 @@ cb_Backend_analytics_dataset_drop(VALUE self, VALUE dataset_name, VALUE datavers
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::analytics_dataset_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.errors.empty()) {
-                exc = cb__map_error_code(resp.ec, fmt::format("unable to drop dataset `{}`.`{}`", req.dataverse_name, req.dataset_name));
+                exc = cb__map_error_code(resp.ctx, fmt::format("unable to drop dataset `{}`.`{}`", req.dataverse_name, req.dataset_name));
             } else {
                 const auto& first_error = resp.errors.front();
-                exc = cb__map_error_code(resp.ec,
+                exc = cb__map_error_code(resp.ctx,
                                          fmt::format("unable to drop dataset `{}`.`{}` ({}: {})",
                                                      req.dataverse_name,
                                                      req.dataset_name,
@@ -6175,12 +6607,12 @@ cb_Backend_analytics_dataset_create(VALUE self,
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::analytics_dataset_create_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.errors.empty()) {
-                exc = cb__map_error_code(resp.ec, fmt::format("unable to create dataset `{}`.`{}`", req.dataverse_name, req.dataset_name));
+                exc = cb__map_error_code(resp.ctx, fmt::format("unable to create dataset `{}`.`{}`", req.dataverse_name, req.dataset_name));
             } else {
                 const auto& first_error = resp.errors.front();
-                exc = cb__map_error_code(resp.ec,
+                exc = cb__map_error_code(resp.ctx,
                                          fmt::format("unable to create dataset `{}`.`{}` ({}: {})",
                                                      req.dataverse_name,
                                                      req.dataset_name,
@@ -6224,13 +6656,13 @@ cb_Backend_analytics_dataverse_drop(VALUE self, VALUE dataverse_name, VALUE igno
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::analytics_dataverse_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.errors.empty()) {
-                exc = cb__map_error_code(resp.ec, fmt::format("unable to drop dataverse `{}`", req.dataverse_name));
+                exc = cb__map_error_code(resp.ctx, fmt::format("unable to drop dataverse `{}`", req.dataverse_name));
             } else {
                 const auto& first_error = resp.errors.front();
                 exc = cb__map_error_code(
-                  resp.ec,
+                  resp.ctx,
                   fmt::format("unable to drop dataverse `{}` ({}: {})", req.dataverse_name, first_error.code, first_error.message));
             }
             break;
@@ -6273,13 +6705,13 @@ cb_Backend_analytics_dataverse_create(VALUE self, VALUE dataverse_name, VALUE ig
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::analytics_dataverse_create_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.errors.empty()) {
-                exc = cb__map_error_code(resp.ec, fmt::format("unable to create dataverse `{}`", req.dataverse_name));
+                exc = cb__map_error_code(resp.ctx, fmt::format("unable to create dataverse `{}`", req.dataverse_name));
             } else {
                 const auto& first_error = resp.errors.front();
                 exc = cb__map_error_code(
-                  resp.ec,
+                  resp.ctx,
                   fmt::format("unable to create dataverse `{}` ({}: {})", req.dataverse_name, first_error.code, first_error.message));
             }
             break;
@@ -6313,25 +6745,26 @@ cb_Backend_analytics_index_get_all(VALUE self, VALUE timeout)
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::analytics_index_get_all_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.errors.empty()) {
-                exc = cb__map_error_code(resp.ec, "unable to fetch all indexes");
+                exc = cb__map_error_code(resp.ctx, "unable to fetch all indexes");
             } else {
                 const auto& first_error = resp.errors.front();
                 exc =
-                  cb__map_error_code(resp.ec, fmt::format("unable to fetch all indexes ({}: {})", first_error.code, first_error.message));
+                  cb__map_error_code(resp.ctx, fmt::format("unable to fetch all indexes ({}: {})", first_error.code, first_error.message));
             }
             break;
         }
         VALUE res = rb_ary_new_capa(static_cast<long>(resp.indexes.size()));
         for (const auto& idx : resp.indexes) {
             VALUE index = rb_hash_new();
-            rb_hash_aset(index, rb_id2sym(rb_intern("name")), rb_str_new(idx.name.data(), static_cast<long>(idx.name.size())));
-            rb_hash_aset(
-              index, rb_id2sym(rb_intern("dataset_name")), rb_str_new(idx.dataset_name.data(), static_cast<long>(idx.dataset_name.size())));
+            rb_hash_aset(index, rb_id2sym(rb_intern("name")), rb_external_str_new(idx.name.data(), static_cast<long>(idx.name.size())));
+            rb_hash_aset(index,
+                         rb_id2sym(rb_intern("dataset_name")),
+                         rb_external_str_new(idx.dataset_name.data(), static_cast<long>(idx.dataset_name.size())));
             rb_hash_aset(index,
                          rb_id2sym(rb_intern("dataverse_name")),
-                         rb_str_new(idx.dataverse_name.data(), static_cast<long>(idx.dataverse_name.size())));
+                         rb_external_str_new(idx.dataverse_name.data(), static_cast<long>(idx.dataverse_name.size())));
             rb_hash_aset(index, rb_id2sym(rb_intern("is_primary")), idx.is_primary ? Qtrue : Qfalse);
             rb_ary_push(res, index);
         }
@@ -6396,13 +6829,13 @@ cb_Backend_analytics_index_create(VALUE self,
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::analytics_index_create_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.errors.empty()) {
                 exc = cb__map_error_code(
-                  resp.ec, fmt::format("unable to create index `{}` on `{}`.`{}`", req.index_name, req.dataverse_name, req.dataset_name));
+                  resp.ctx, fmt::format("unable to create index `{}` on `{}`.`{}`", req.index_name, req.dataverse_name, req.dataset_name));
             } else {
                 const auto& first_error = resp.errors.front();
-                exc = cb__map_error_code(resp.ec,
+                exc = cb__map_error_code(resp.ctx,
                                          fmt::format("unable to create index `{}` on `{}`.`{}` ({}: {})",
                                                      req.index_name,
                                                      req.dataverse_name,
@@ -6460,13 +6893,13 @@ cb_Backend_analytics_index_drop(VALUE self,
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::analytics_index_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.errors.empty()) {
                 exc = cb__map_error_code(
-                  resp.ec, fmt::format("unable to drop index `{}`.`{}`.`{}`", req.dataverse_name, req.dataset_name, req.index_name));
+                  resp.ctx, fmt::format("unable to drop index `{}`.`{}`.`{}`", req.dataverse_name, req.dataset_name, req.index_name));
             } else {
                 const auto& first_error = resp.errors.front();
-                exc = cb__map_error_code(resp.ec,
+                exc = cb__map_error_code(resp.ctx,
                                          fmt::format("unable to drop index `{}`.`{}`.`{}` ({}: {})",
                                                      req.dataverse_name,
                                                      req.dataset_name,
@@ -6517,12 +6950,12 @@ cb_Backend_analytics_link_connect(VALUE self, VALUE link_name, VALUE force, VALU
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::analytics_link_connect_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.errors.empty()) {
-                exc = cb__map_error_code(resp.ec, fmt::format("unable to connect link `{}` on `{}`", req.link_name, req.dataverse_name));
+                exc = cb__map_error_code(resp.ctx, fmt::format("unable to connect link `{}` on `{}`", req.link_name, req.dataverse_name));
             } else {
                 const auto& first_error = resp.errors.front();
-                exc = cb__map_error_code(resp.ec,
+                exc = cb__map_error_code(resp.ctx,
                                          fmt::format("unable to connect link `{}` on `{}` ({}: {})",
                                                      req.link_name,
                                                      req.dataverse_name,
@@ -6569,12 +7002,13 @@ cb_Backend_analytics_link_disconnect(VALUE self, VALUE link_name, VALUE datavers
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::analytics_link_disconnect_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.errors.empty()) {
-                exc = cb__map_error_code(resp.ec, fmt::format("unable to disconnect link `{}` on `{}`", req.link_name, req.dataverse_name));
+                exc =
+                  cb__map_error_code(resp.ctx, fmt::format("unable to disconnect link `{}` on `{}`", req.link_name, req.dataverse_name));
             } else {
                 const auto& first_error = resp.errors.front();
-                exc = cb__map_error_code(resp.ec,
+                exc = cb__map_error_code(resp.ctx,
                                          fmt::format("unable to disconnect link `{}` on `{}` ({}: {})",
                                                      req.link_name,
                                                      req.dataverse_name,
@@ -6663,6 +7097,23 @@ cb_Backend_document_analytics(VALUE self, VALUE statement, VALUE options)
                 req.scan_consistency = couchbase::operations::analytics_request::scan_consistency_type::request_plus;
             }
         }
+        VALUE scope_qualifier = rb_hash_aref(options, rb_id2sym(rb_intern("scope_qualifier")));
+        if (!NIL_P(scope_qualifier) && TYPE(scope_qualifier) == T_STRING) {
+            req.scope_qualifier.emplace(std::string(RSTRING_PTR(scope_qualifier), static_cast<std::size_t>(RSTRING_LEN(scope_qualifier))));
+        } else {
+            VALUE scope_name = rb_hash_aref(options, rb_id2sym(rb_intern("scope_name")));
+            if (!NIL_P(scope_name) && TYPE(scope_name) == T_STRING) {
+                req.scope_name.emplace(std::string(RSTRING_PTR(scope_name), static_cast<std::size_t>(RSTRING_LEN(scope_name))));
+                VALUE bucket_name = rb_hash_aref(options, rb_id2sym(rb_intern("bucket_name")));
+                if (NIL_P(bucket_name)) {
+                    exc = rb_exc_new_cstr(
+                      eInvalidArgument,
+                      fmt::format("bucket must be specified for analytics query in scope \"{}\"", req.scope_name.value()).c_str());
+                    break;
+                }
+                req.bucket_name.emplace(std::string(RSTRING_PTR(bucket_name), static_cast<std::size_t>(RSTRING_LEN(bucket_name))));
+            }
+        }
 
         VALUE raw_params = rb_hash_aref(options, rb_id2sym(rb_intern("raw_parameters")));
         if (!NIL_P(raw_params)) {
@@ -6675,20 +7126,13 @@ cb_Backend_document_analytics(VALUE self, VALUE statement, VALUE options)
         backend->cluster->execute_http(req,
                                        [barrier](couchbase::operations::analytics_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             if (resp.payload.meta_data.errors && !resp.payload.meta_data.errors->empty()) {
                 const auto& first_error = resp.payload.meta_data.errors->front();
-                exc = cb__map_error_code(resp.ec,
-                                         fmt::format("unable to execute analytics query: \"{}{}\" ({}: {})",
-                                                     req.statement.substr(0, 50),
-                                                     req.statement.size() > 50 ? "..." : "",
-                                                     first_error.code,
-                                                     first_error.message));
+                exc = cb__map_error_code(resp.ctx,
+                                         fmt::format("unable to execute analytics query ({}: {})", first_error.code, first_error.message));
             } else {
-                exc = cb__map_error_code(resp.ec,
-                                         fmt::format("unable to execute analytics query: \"{}{}\"",
-                                                     req.statement.substr(0, 50),
-                                                     req.statement.size() > 50 ? "..." : ""));
+                exc = cb__map_error_code(resp.ctx, "unable to execute analytics query");
             }
             break;
         }
@@ -6696,40 +7140,43 @@ cb_Backend_document_analytics(VALUE self, VALUE statement, VALUE options)
         VALUE rows = rb_ary_new_capa(static_cast<long>(resp.payload.rows.size()));
         rb_hash_aset(res, rb_id2sym(rb_intern("rows")), rows);
         for (auto& row : resp.payload.rows) {
-            rb_ary_push(rows, rb_str_new(row.data(), static_cast<long>(row.size())));
+            rb_ary_push(rows, rb_external_str_new(row.data(), static_cast<long>(row.size())));
         }
         VALUE meta = rb_hash_new();
         rb_hash_aset(res, rb_id2sym(rb_intern("meta")), meta);
         rb_hash_aset(meta,
                      rb_id2sym(rb_intern("status")),
                      rb_id2sym(rb_intern2(resp.payload.meta_data.status.data(), static_cast<long>(resp.payload.meta_data.status.size()))));
-        rb_hash_aset(meta,
-                     rb_id2sym(rb_intern("request_id")),
-                     rb_str_new(resp.payload.meta_data.request_id.data(), static_cast<long>(resp.payload.meta_data.request_id.size())));
         rb_hash_aset(
           meta,
-          rb_id2sym(rb_intern("client_context_id")),
-          rb_str_new(resp.payload.meta_data.client_context_id.data(), static_cast<long>(resp.payload.meta_data.client_context_id.size())));
+          rb_id2sym(rb_intern("request_id")),
+          rb_external_str_new(resp.payload.meta_data.request_id.data(), static_cast<long>(resp.payload.meta_data.request_id.size())));
+        rb_hash_aset(meta,
+                     rb_id2sym(rb_intern("client_context_id")),
+                     rb_external_str_new(resp.payload.meta_data.client_context_id.data(),
+                                         static_cast<long>(resp.payload.meta_data.client_context_id.size())));
         if (resp.payload.meta_data.signature) {
-            rb_hash_aset(meta,
-                         rb_id2sym(rb_intern("signature")),
-                         rb_str_new(resp.payload.meta_data.signature->data(), static_cast<long>(resp.payload.meta_data.signature->size())));
+            rb_hash_aset(
+              meta,
+              rb_id2sym(rb_intern("signature")),
+              rb_external_str_new(resp.payload.meta_data.signature->data(), static_cast<long>(resp.payload.meta_data.signature->size())));
         }
         if (resp.payload.meta_data.profile) {
-            rb_hash_aset(meta,
-                         rb_id2sym(rb_intern("profile")),
-                         rb_str_new(resp.payload.meta_data.profile->data(), static_cast<long>(resp.payload.meta_data.profile->size())));
+            rb_hash_aset(
+              meta,
+              rb_id2sym(rb_intern("profile")),
+              rb_external_str_new(resp.payload.meta_data.profile->data(), static_cast<long>(resp.payload.meta_data.profile->size())));
         }
         VALUE metrics = rb_hash_new();
         rb_hash_aset(meta, rb_id2sym(rb_intern("metrics")), metrics);
         rb_hash_aset(metrics,
                      rb_id2sym(rb_intern("elapsed_time")),
-                     rb_str_new(resp.payload.meta_data.metrics.elapsed_time.data(),
-                                static_cast<long>(resp.payload.meta_data.metrics.elapsed_time.size())));
+                     rb_external_str_new(resp.payload.meta_data.metrics.elapsed_time.data(),
+                                         static_cast<long>(resp.payload.meta_data.metrics.elapsed_time.size())));
         rb_hash_aset(metrics,
                      rb_id2sym(rb_intern("execution_time")),
-                     rb_str_new(resp.payload.meta_data.metrics.execution_time.data(),
-                                static_cast<long>(resp.payload.meta_data.metrics.execution_time.size())));
+                     rb_external_str_new(resp.payload.meta_data.metrics.execution_time.data(),
+                                         static_cast<long>(resp.payload.meta_data.metrics.execution_time.size())));
         rb_hash_aset(metrics, rb_id2sym(rb_intern("result_count")), ULL2NUM(resp.payload.meta_data.metrics.result_count));
         rb_hash_aset(metrics, rb_id2sym(rb_intern("result_size")), ULL2NUM(resp.payload.meta_data.metrics.result_count));
         if (resp.payload.meta_data.metrics.sort_count) {
@@ -6762,14 +7209,16 @@ cb_Backend_parse_connection_string(VALUE self, VALUE connection_string)
 
     VALUE res = rb_hash_new();
     if (!connstr.scheme.empty()) {
-        rb_hash_aset(res, rb_id2sym(rb_intern("scheme")), rb_str_new(connstr.scheme.data(), static_cast<long>(connstr.scheme.size())));
+        rb_hash_aset(
+          res, rb_id2sym(rb_intern("scheme")), rb_external_str_new(connstr.scheme.data(), static_cast<long>(connstr.scheme.size())));
         rb_hash_aset(res, rb_id2sym(rb_intern("tls")), connstr.tls ? Qtrue : Qfalse);
     }
 
     VALUE nodes = rb_ary_new_capa(static_cast<long>(connstr.bootstrap_nodes.size()));
     for (const auto& entry : connstr.bootstrap_nodes) {
         VALUE node = rb_hash_new();
-        rb_hash_aset(node, rb_id2sym(rb_intern("address")), rb_str_new(entry.address.data(), static_cast<long>(entry.address.size())));
+        rb_hash_aset(
+          node, rb_id2sym(rb_intern("address")), rb_external_str_new(entry.address.data(), static_cast<long>(entry.address.size())));
         if (entry.port > 0) {
             rb_hash_aset(node, rb_id2sym(rb_intern("port")), UINT2NUM(entry.port));
         }
@@ -6801,15 +7250,15 @@ cb_Backend_parse_connection_string(VALUE self, VALUE connection_string)
     VALUE params = rb_hash_new();
     for (const auto& param : connstr.params) {
         rb_hash_aset(params,
-                     rb_str_new(param.first.data(), static_cast<long>(param.first.size())),
-                     rb_str_new(param.second.data(), static_cast<long>(param.second.size())));
+                     rb_external_str_new(param.first.data(), static_cast<long>(param.first.size())),
+                     rb_external_str_new(param.second.data(), static_cast<long>(param.second.size())));
     }
     rb_hash_aset(res, rb_id2sym(rb_intern("params")), params);
 
     if (connstr.default_bucket_name) {
         rb_hash_aset(res,
                      rb_id2sym(rb_intern("default_bucket_name")),
-                     rb_str_new(connstr.default_bucket_name->data(), static_cast<long>(connstr.default_bucket_name->size())));
+                     rb_external_str_new(connstr.default_bucket_name->data(), static_cast<long>(connstr.default_bucket_name->size())));
     }
     if (connstr.default_port > 0) {
         rb_hash_aset(res, rb_id2sym(rb_intern("default_port")), UINT2NUM(connstr.default_port));
@@ -6825,7 +7274,8 @@ cb_Backend_parse_connection_string(VALUE self, VALUE connection_string)
             break;
     }
     if (connstr.error) {
-        rb_hash_aset(res, rb_id2sym(rb_intern("error")), rb_str_new(connstr.error->data(), static_cast<long>(connstr.error->size())));
+        rb_hash_aset(
+          res, rb_id2sym(rb_intern("error")), rb_external_str_new(connstr.error->data(), static_cast<long>(connstr.error->size())));
     }
     return res;
 }
@@ -6869,15 +7319,15 @@ cb_Backend_view_index_get_all(VALUE self, VALUE bucket_name, VALUE name_space, V
         backend->cluster->execute_http(
           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");
+        if (resp.ctx.ec) {
+            exc = cb__map_error_code(resp.ctx, "unable to get list of the design documents");
             break;
         }
         VALUE res = rb_ary_new_capa(static_cast<long>(resp.design_documents.size()));
         for (const auto& entry : resp.design_documents) {
             VALUE dd = rb_hash_new();
-            rb_hash_aset(dd, rb_id2sym(rb_intern("name")), rb_str_new(entry.name.data(), static_cast<long>(entry.name.size())));
-            rb_hash_aset(dd, rb_id2sym(rb_intern("rev")), rb_str_new(entry.rev.data(), static_cast<long>(entry.rev.size())));
+            rb_hash_aset(dd, rb_id2sym(rb_intern("name")), rb_external_str_new(entry.name.data(), static_cast<long>(entry.name.size())));
+            rb_hash_aset(dd, rb_id2sym(rb_intern("rev")), rb_external_str_new(entry.rev.data(), static_cast<long>(entry.rev.size())));
             switch (entry.ns) {
                 case couchbase::operations::design_document::name_space::development:
                     rb_hash_aset(dd, rb_id2sym(rb_intern("namespace")), rb_id2sym(rb_intern("development")));
@@ -6888,18 +7338,19 @@ cb_Backend_view_index_get_all(VALUE self, VALUE bucket_name, VALUE name_space, V
             }
             VALUE views = rb_hash_new();
             for (const auto& view_entry : entry.views) {
-                VALUE view_name = rb_str_new(view_entry.first.data(), static_cast<long>(view_entry.first.size()));
+                VALUE view_name = rb_external_str_new(view_entry.first.data(), static_cast<long>(view_entry.first.size()));
                 VALUE view = rb_hash_new();
                 rb_hash_aset(view, rb_id2sym(rb_intern("name")), view_name);
                 if (view_entry.second.map) {
                     rb_hash_aset(view,
                                  rb_id2sym(rb_intern("map")),
-                                 rb_str_new(view_entry.second.map->data(), static_cast<long>(view_entry.second.map->size())));
+                                 rb_external_str_new(view_entry.second.map->data(), static_cast<long>(view_entry.second.map->size())));
                 }
                 if (view_entry.second.reduce) {
-                    rb_hash_aset(view,
-                                 rb_id2sym(rb_intern("reduce")),
-                                 rb_str_new(view_entry.second.reduce->data(), static_cast<long>(view_entry.second.reduce->size())));
+                    rb_hash_aset(
+                      view,
+                      rb_id2sym(rb_intern("reduce")),
+                      rb_external_str_new(view_entry.second.reduce->data(), static_cast<long>(view_entry.second.reduce->size())));
                 }
                 rb_hash_aset(views, view_name, view);
             }
@@ -6953,16 +7404,17 @@ cb_Backend_view_index_get(VALUE self, VALUE bucket_name, VALUE document_name, VA
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::view_index_get_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             exc = cb__map_error_code(
-              resp.ec,
+              resp.ctx,
               fmt::format(R"(unable to get design document "{}" ({}) on bucket "{}")", req.document_name, req.name_space, req.bucket_name));
             break;
         }
         VALUE res = rb_hash_new();
         rb_hash_aset(
-          res, rb_id2sym(rb_intern("name")), rb_str_new(resp.document.name.data(), static_cast<long>(resp.document.name.size())));
-        rb_hash_aset(res, rb_id2sym(rb_intern("rev")), rb_str_new(resp.document.rev.data(), static_cast<long>(resp.document.rev.size())));
+          res, rb_id2sym(rb_intern("name")), rb_external_str_new(resp.document.name.data(), static_cast<long>(resp.document.name.size())));
+        rb_hash_aset(
+          res, rb_id2sym(rb_intern("rev")), rb_external_str_new(resp.document.rev.data(), static_cast<long>(resp.document.rev.size())));
         switch (resp.document.ns) {
             case couchbase::operations::design_document::name_space::development:
                 rb_hash_aset(res, rb_id2sym(rb_intern("namespace")), rb_id2sym(rb_intern("development")));
@@ -6973,18 +7425,18 @@ cb_Backend_view_index_get(VALUE self, VALUE bucket_name, VALUE document_name, VA
         }
         VALUE views = rb_hash_new();
         for (const auto& view_entry : resp.document.views) {
-            VALUE view_name = rb_str_new(view_entry.first.data(), static_cast<long>(view_entry.first.size()));
+            VALUE view_name = rb_external_str_new(view_entry.first.data(), static_cast<long>(view_entry.first.size()));
             VALUE view = rb_hash_new();
             rb_hash_aset(view, rb_id2sym(rb_intern("name")), view_name);
             if (view_entry.second.map) {
                 rb_hash_aset(view,
                              rb_id2sym(rb_intern("map")),
-                             rb_str_new(view_entry.second.map->data(), static_cast<long>(view_entry.second.map->size())));
+                             rb_external_str_new(view_entry.second.map->data(), static_cast<long>(view_entry.second.map->size())));
             }
             if (view_entry.second.reduce) {
                 rb_hash_aset(view,
                              rb_id2sym(rb_intern("reduce")),
-                             rb_str_new(view_entry.second.reduce->data(), static_cast<long>(view_entry.second.reduce->size())));
+                             rb_external_str_new(view_entry.second.reduce->data(), static_cast<long>(view_entry.second.reduce->size())));
             }
             rb_hash_aset(views, view_name, view);
         }
@@ -7036,9 +7488,9 @@ cb_Backend_view_index_drop(VALUE self, VALUE bucket_name, VALUE document_name, V
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::view_index_drop_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             exc = cb__map_error_code(
-              resp.ec,
+              resp.ctx,
               fmt::format(
                 R"(unable to drop design document "{}" ({}) on bucket "{}")", req.document_name, req.name_space, req.bucket_name));
             break;
@@ -7117,9 +7569,9 @@ cb_Backend_view_index_upsert(VALUE self, VALUE bucket_name, VALUE document, VALU
         backend->cluster->execute_http(
           req, [barrier](couchbase::operations::view_index_upsert_response&& resp) mutable { barrier->set_value(resp); });
         auto resp = f.get();
-        if (resp.ec) {
+        if (resp.ctx.ec) {
             exc = cb__map_error_code(
-              resp.ec,
+              resp.ctx,
               fmt::format(
                 R"(unable to store design document "{}" ({}) on bucket "{}")", req.document.name, req.document.ns, req.bucket_name));
             break;
@@ -7267,24 +7719,12 @@ cb_Backend_document_view(VALUE self, VALUE bucket_name, VALUE design_document_na
         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.ctx.ec) {
             if (resp.error) {
-                exc = cb__map_error_code(
-                  resp.ec,
-                  fmt::format(R"(unable to execute query for view "{}" of design document "{}" ({}) on bucket "{}": {} ({}))",
-                              req.view_name,
-                              req.document_name,
-                              req.name_space,
-                              req.bucket_name,
-                              resp.error->code,
-                              resp.error->message));
+                exc = cb__map_error_code(resp.ctx,
+                                         fmt::format(R"(unable to execute view query {} ({}))", resp.error->code, resp.error->message));
             } else {
-                exc = cb__map_error_code(resp.ec,
-                                         fmt::format(R"(unable to execute query for view "{}" of design document "{}" ({}) on bucket "{}")",
-                                                     req.view_name,
-                                                     req.document_name,
-                                                     req.name_space,
-                                                     req.bucket_name));
+                exc = cb__map_error_code(resp.ctx, "unable to execute view query");
             }
             break;
         }
@@ -7297,7 +7737,7 @@ cb_Backend_document_view(VALUE self, VALUE bucket_name, VALUE design_document_na
         if (resp.meta_data.debug_info) {
             rb_hash_aset(meta,
                          rb_id2sym(rb_intern("debug_info")),
-                         rb_str_new(resp.meta_data.debug_info->data(), static_cast<long>(resp.meta_data.debug_info->size())));
+                         rb_external_str_new(resp.meta_data.debug_info->data(), static_cast<long>(resp.meta_data.debug_info->size())));
         }
         rb_hash_aset(res, rb_id2sym(rb_intern("meta")), meta);
 
@@ -7305,10 +7745,11 @@ cb_Backend_document_view(VALUE self, VALUE bucket_name, VALUE design_document_na
         for (const auto& entry : resp.rows) {
             VALUE row = rb_hash_new();
             if (entry.id) {
-                rb_hash_aset(row, rb_id2sym(rb_intern("id")), rb_str_new(entry.id->data(), static_cast<long>(entry.id->size())));
+                rb_hash_aset(row, rb_id2sym(rb_intern("id")), rb_external_str_new(entry.id->data(), static_cast<long>(entry.id->size())));
             }
-            rb_hash_aset(row, rb_id2sym(rb_intern("key")), rb_str_new(entry.key.data(), static_cast<long>(entry.key.size())));
-            rb_hash_aset(row, rb_id2sym(rb_intern("value")), rb_str_new(entry.value.data(), static_cast<long>(entry.value.size())));
+            rb_hash_aset(row, rb_id2sym(rb_intern("key")), rb_external_str_new(entry.key.data(), static_cast<long>(entry.key.size())));
+            rb_hash_aset(
+              row, rb_id2sym(rb_intern("value")), rb_external_str_new(entry.value.data(), static_cast<long>(entry.value.size())));
             rb_ary_push(rows, row);
         }
         rb_hash_aset(res, rb_id2sym(rb_intern("rows")), rows);
@@ -7379,7 +7820,7 @@ cb_Backend_snappy_compress(VALUE self, VALUE data)
 
     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));
+    return rb_external_str_new(compressed.data(), static_cast<long>(compressed_size));
 }
 
 static VALUE
@@ -7391,7 +7832,7 @@ cb_Backend_snappy_uncompress(VALUE self, VALUE data)
     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()));
+        return rb_external_str_new(uncompressed.data(), static_cast<long>(uncompressed.size()));
     }
     rb_raise(rb_eArgError, "Unable to decompress buffer");
     return Qnil;
@@ -7410,7 +7851,7 @@ cb_Backend_leb128_encode(VALUE self, VALUE 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()));
+    return rb_external_str_new(buf.data(), static_cast<long>(buf.size()));
 }
 
 static VALUE
@@ -7421,7 +7862,7 @@ cb_Backend_leb128_decode(VALUE self, VALUE data)
     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()) {
+        if (rv.second.data() != nullptr) {
             return ULL2NUM(rv.first);
         }
     }
@@ -7554,7 +7995,10 @@ init_logger()
         spdlog::cfg::helpers::load_levels(env_val);
     }
 
-    couchbase::platform::install_backtrace_terminate_handler();
+    env_val = spdlog::details::os::getenv("COUCHBASE_BACKEND_DONT_INSTALL_TERMINATE_HANDLER");
+    if (env_val.empty()) {
+        couchbase::platform::install_backtrace_terminate_handler();
+    }
 }
 
 extern "C" {