couchbase 3.8.1 → 3.9.0

data/ext/rcb_users.cxx

@@ -89,10 +89,8 @@ cb_Backend_role_get_all(VALUE self, VALUE timeout, VALUE observability_handler)
     }
     return res;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -179,7 +177,7 @@ cb_Backend_user_get_all(VALUE self, VALUE domain, VALUE timeout, VALUE observabi
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(domain, T_SYMBOL);
+  cb_check_type(domain, T_SYMBOL);
 
   try {
     core::operations::management::user_get_all_request req{};
@@ -190,7 +188,7 @@ cb_Backend_user_get_all(VALUE self, VALUE domain, VALUE timeout, VALUE observabi
       req.domain = core::management::rbac::auth_domain::external;
     } else {
       throw ruby_exception(exc_invalid_argument(),
-                           rb_sprintf("unsupported authentication domain: %+" PRIsVALUE, domain));
+                           cb_sprintf("unsupported authentication domain: %+" PRIsVALUE, domain));
     }
     auto parent_span = cb_create_parent_span(req, self);
     std::promise<core::operations::management::user_get_all_response> promise;
@@ -212,10 +210,8 @@ cb_Backend_user_get_all(VALUE self, VALUE domain, VALUE timeout, VALUE observabi
     }
     return res;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -229,8 +225,8 @@ cb_Backend_user_get(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(domain, T_SYMBOL);
-  Check_Type(username, T_STRING);
+  cb_check_type(domain, T_SYMBOL);
+  cb_check_type(username, T_STRING);
 
   try {
     core::operations::management::user_get_request req{};
@@ -241,7 +237,7 @@ cb_Backend_user_get(VALUE self,
       req.domain = core::management::rbac::auth_domain::external;
     } else {
       throw ruby_exception(exc_invalid_argument(),
-                           rb_sprintf("unsupported authentication domain: %+" PRIsVALUE, domain));
+                           cb_sprintf("unsupported authentication domain: %+" PRIsVALUE, domain));
     }
     req.username = cb_string_new(username);
     auto parent_span = cb_create_parent_span(req, self);
@@ -260,10 +256,8 @@ cb_Backend_user_get(VALUE self,
     cb_extract_user(resp.user, res);
     return res;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -277,8 +271,8 @@ cb_Backend_user_drop(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(domain, T_SYMBOL);
-  Check_Type(username, T_STRING);
+  cb_check_type(domain, T_SYMBOL);
+  cb_check_type(username, T_STRING);
 
   try {
     core::operations::management::user_drop_request req{};
@@ -289,7 +283,7 @@ cb_Backend_user_drop(VALUE self,
       req.domain = core::management::rbac::auth_domain::external;
     } else {
       throw ruby_exception(exc_invalid_argument(),
-                           rb_sprintf("unsupported authentication domain: %+" PRIsVALUE, domain));
+                           cb_sprintf("unsupported authentication domain: %+" PRIsVALUE, domain));
     }
     req.username = cb_string_new(username);
     auto parent_span = cb_create_parent_span(req, self);
@@ -306,10 +300,8 @@ cb_Backend_user_drop(VALUE self,
 
     return Qtrue;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -323,8 +315,8 @@ cb_Backend_user_upsert(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(domain, T_SYMBOL);
-  Check_Type(user, T_HASH);
+  cb_check_type(domain, T_SYMBOL);
+  cb_check_type(user, T_HASH);
 
   try {
     core::operations::management::user_upsert_request req{};
@@ -335,7 +327,7 @@ cb_Backend_user_upsert(VALUE self,
       req.domain = core::management::rbac::auth_domain::external;
     } else {
       throw ruby_exception(exc_invalid_argument(),
-                           rb_sprintf("unsupported authentication domain: %+" PRIsVALUE, domain));
+                           cb_sprintf("unsupported authentication domain: %+" PRIsVALUE, domain));
     }
     VALUE name = rb_hash_aref(user, rb_id2sym(rb_intern("username")));
     if (NIL_P(name) || TYPE(name) != T_STRING) {
@@ -406,10 +398,8 @@ cb_Backend_user_upsert(VALUE self,
 
     return Qtrue;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -422,7 +412,7 @@ cb_Backend_change_password(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(new_password, T_STRING);
+  cb_check_type(new_password, T_STRING);
 
   try {
     core::operations::management::change_password_request req{};
@@ -442,10 +432,8 @@ cb_Backend_change_password(VALUE self,
 
     return Qtrue;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -508,10 +496,8 @@ cb_Backend_group_get_all(VALUE self, VALUE timeout, VALUE observability_handler)
     }
     return res;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -521,7 +507,7 @@ cb_Backend_group_get(VALUE self, VALUE name, VALUE timeout, VALUE observability_
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(name, T_STRING);
+  cb_check_type(name, T_STRING);
 
   try {
     core::operations::management::group_get_request req{};
@@ -543,10 +529,8 @@ cb_Backend_group_get(VALUE self, VALUE name, VALUE timeout, VALUE observability_
     cb_extract_group(resp.group, res);
     return res;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -556,7 +540,7 @@ cb_Backend_group_drop(VALUE self, VALUE name, VALUE timeout, VALUE observability
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(name, T_STRING);
+  cb_check_type(name, T_STRING);
 
   try {
     core::operations::management::group_drop_request req{};
@@ -576,10 +560,8 @@ cb_Backend_group_drop(VALUE self, VALUE name, VALUE timeout, VALUE observability
     }
     return Qtrue;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -589,7 +571,7 @@ cb_Backend_group_upsert(VALUE self, VALUE group, VALUE timeout, VALUE observabil
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(group, T_HASH);
+  cb_check_type(group, T_HASH);
 
   try {
     core::operations::management::group_upsert_request req{};
@@ -652,10 +634,8 @@ cb_Backend_group_upsert(VALUE self, VALUE group, VALUE timeout, VALUE observabil
     }
     return Qtrue;
   } catch (const std::system_error& se) {
-    rb_exc_raise(cb_map_error_code(
+    throw ruby_exception(cb_map_error_code(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
   return Qnil;
 }
@@ -664,16 +644,16 @@ cb_Backend_group_upsert(VALUE self, VALUE group, VALUE timeout, VALUE observabil
 void
 init_users(VALUE cBackend)
 {
-  rb_define_method(cBackend, "role_get_all", cb_Backend_role_get_all, 2);
-  rb_define_method(cBackend, "user_get_all", cb_Backend_user_get_all, 3);
-  rb_define_method(cBackend, "user_get", cb_Backend_user_get, 4);
-  rb_define_method(cBackend, "user_drop", cb_Backend_user_drop, 4);
-  rb_define_method(cBackend, "user_upsert", cb_Backend_user_upsert, 4);
-  rb_define_method(cBackend, "group_get_all", cb_Backend_group_get_all, 2);
-  rb_define_method(cBackend, "group_get", cb_Backend_group_get, 3);
-  rb_define_method(cBackend, "group_drop", cb_Backend_group_drop, 3);
-  rb_define_method(cBackend, "group_upsert", cb_Backend_group_upsert, 3);
-
-  rb_define_method(cBackend, "change_password", cb_Backend_change_password, 3);
+  rb_define_method(cBackend, "role_get_all", cb_method<cb_Backend_role_get_all>::invoke, 2);
+  rb_define_method(cBackend, "user_get_all", cb_method<cb_Backend_user_get_all>::invoke, 3);
+  rb_define_method(cBackend, "user_get", cb_method<cb_Backend_user_get>::invoke, 4);
+  rb_define_method(cBackend, "user_drop", cb_method<cb_Backend_user_drop>::invoke, 4);
+  rb_define_method(cBackend, "user_upsert", cb_method<cb_Backend_user_upsert>::invoke, 4);
+  rb_define_method(cBackend, "group_get_all", cb_method<cb_Backend_group_get_all>::invoke, 2);
+  rb_define_method(cBackend, "group_get", cb_method<cb_Backend_group_get>::invoke, 3);
+  rb_define_method(cBackend, "group_drop", cb_method<cb_Backend_group_drop>::invoke, 3);
+  rb_define_method(cBackend, "group_upsert", cb_method<cb_Backend_group_upsert>::invoke, 3);
+
+  rb_define_method(cBackend, "change_password", cb_method<cb_Backend_change_password>::invoke, 3);
 }
 } // namespace couchbase::ruby

data/ext/rcb_utils.cxx

@@ -15,13 +15,17 @@
  *   limitations under the License.
  */
 
+#include <couchbase/best_effort_retry_strategy.hxx>
 #include <couchbase/expiry.hxx>
+#include <couchbase/fail_fast_retry_strategy.hxx>
 
 #include <core/utils/binary.hxx>
 
 #include "rcb_exceptions.hxx"
 #include "rcb_utils.hxx"
 
+#include <chrono>
+#include <cinttypes>
 #include <cstdint>
 #include <ruby.h>
 
@@ -99,7 +103,7 @@ extract_legacy_durability_replicate_to(VALUE options)
 {
   static VALUE property_name{ rb_id2sym(rb_intern("replicate_to")) };
   if (VALUE val = rb_hash_aref(options, property_name); !NIL_P(val)) {
-    ID mode = rb_sym2id(val);
+    ID mode = cb_sym2id(val);
     if (mode == rb_intern("none")) {
       return {};
     }
@@ -113,7 +117,7 @@ extract_legacy_durability_replicate_to(VALUE options)
       return couchbase::replicate_to::three;
     }
     throw ruby_exception(exc_invalid_argument(),
-                         rb_sprintf("unknown replicate_to: %+" PRIsVALUE, val));
+                         cb_sprintf("unknown replicate_to: %+" PRIsVALUE, val));
   }
   return couchbase::replicate_to::none;
 }
@@ -123,7 +127,7 @@ extract_legacy_durability_persist_to(VALUE options)
 {
   static VALUE property_name{ rb_id2sym(rb_intern("persist_to")) };
   if (VALUE val = rb_hash_aref(options, property_name); !NIL_P(val)) {
-    ID mode = rb_sym2id(val);
+    ID mode = cb_sym2id(val);
     if (mode == rb_intern("none")) {
       return {};
     }
@@ -143,7 +147,7 @@ extract_legacy_durability_persist_to(VALUE options)
       return couchbase::persist_to::four;
     }
     throw ruby_exception(exc_invalid_argument(),
-                         rb_sprintf("unknown persist_to value: %+" PRIsVALUE, val));
+                         cb_sprintf("unknown persist_to value: %+" PRIsVALUE, val));
   }
   return couchbase::persist_to::none;
 }
@@ -165,7 +169,7 @@ cb_check_type(VALUE object, int type)
   if (auto object_type = TYPE(object);
       object_type != type || (object_type == T_DATA && RTYPEDDATA_P(object))) {
     throw ruby_exception(rb_eTypeError,
-                         rb_sprintf("wrong argument type %" PRIsVALUE " (expected %s)",
+                         cb_sprintf("wrong argument type %" PRIsVALUE " (expected %s)",
                                     cb_displaying_class_of(object),
                                     cb_builtin_type_name(type)));
   }
@@ -225,7 +229,7 @@ void
 cb_extract_flags(std::uint32_t& field, VALUE flags)
 {
   cb_check_type(flags, T_FIXNUM);
-  field = FIX2UINT(flags);
+  field = cb_num2uint(flags);
 }
 
 void
@@ -240,6 +244,31 @@ cb_extract_timeout(std::optional<std::chrono::milliseconds>& field, VALUE option
   cb_extract_duration(field, options, "timeout");
 }
 
+auto
+cb_extract_retry_strategy(VALUE options) -> std::shared_ptr<couchbase::retry_strategy>
+{
+  if (NIL_P(options) || TYPE(options) != T_HASH) {
+    return nullptr;
+  }
+  static VALUE property_name{ rb_id2sym(rb_intern("retry_strategy")) };
+  VALUE val = rb_hash_aref(options, property_name);
+  if (NIL_P(val)) {
+    return nullptr;
+  }
+  if (TYPE(val) == T_SYMBOL) {
+    ID name = rb_sym2id(val);
+    if (name == rb_intern("best_effort")) {
+      return couchbase::make_best_effort_retry_strategy();
+    }
+    if (name == rb_intern("fail_fast")) {
+      return couchbase::make_fail_fast_retry_strategy();
+    }
+  }
+  throw ruby_exception(
+    exc_invalid_argument(),
+    cb_sprintf("retry_strategy must be :best_effort or :fail_fast, but given %+" PRIsVALUE, val));
+}
+
 void
 cb_extract_option_symbol(VALUE& val, VALUE options, const char* name)
 {
@@ -252,7 +281,7 @@ cb_extract_option_symbol(VALUE& val, VALUE options, const char* name)
       return;
     }
     throw couchbase::ruby::ruby_exception(
-      rb_eArgError, rb_sprintf("%s must be an Symbol, but given %+" PRIsVALUE, name, val));
+      rb_eArgError, cb_sprintf("%s must be an Symbol, but given %+" PRIsVALUE, name, val));
   }
 }
 
@@ -268,7 +297,7 @@ cb_extract_option_string(VALUE& val, VALUE options, const char* name)
       return;
     }
     throw couchbase::ruby::ruby_exception(
-      rb_eArgError, rb_sprintf("%s must be an String, but given %+" PRIsVALUE, name, val));
+      rb_eArgError, cb_sprintf("%s must be an String, but given %+" PRIsVALUE, name, val));
   }
 }
 
@@ -285,7 +314,7 @@ cb_extract_option_string(std::string& target, VALUE options, const char* name)
       return;
     }
     throw couchbase::ruby::ruby_exception(
-      rb_eArgError, rb_sprintf("%s must be an String, but given %+" PRIsVALUE, name, val));
+      rb_eArgError, cb_sprintf("%s must be an String, but given %+" PRIsVALUE, name, val));
   }
 }
 
@@ -302,7 +331,7 @@ cb_extract_option_string(std::optional<std::string>& target, VALUE options, cons
       return;
     }
     throw couchbase::ruby::ruby_exception(
-      rb_eArgError, rb_sprintf("%s must be an String, but given %+" PRIsVALUE, name, val));
+      rb_eArgError, cb_sprintf("%s must be an String, but given %+" PRIsVALUE, name, val));
   }
 }
 
@@ -322,7 +351,7 @@ cb_extract_option_bignum(VALUE& val, VALUE options, const char* name)
         break;
     }
     throw couchbase::ruby::ruby_exception(
-      rb_eArgError, rb_sprintf("%s must be an Integer, but given %+" PRIsVALUE, name, val));
+      rb_eArgError, cb_sprintf("%s must be an Integer, but given %+" PRIsVALUE, name, val));
   }
 }
 
@@ -338,7 +367,7 @@ cb_extract_option_array(VALUE& val, VALUE options, const char* name)
       return;
     }
     throw couchbase::ruby::ruby_exception(
-      rb_eArgError, rb_sprintf("%s must be an Array, but given %+" PRIsVALUE, name, val));
+      rb_eArgError, cb_sprintf("%s must be an Array, but given %+" PRIsVALUE, name, val));
   }
 }
 
@@ -351,7 +380,7 @@ cb_cas_to_num(const couchbase::cas& cas)
 couchbase::cas
 cb_num_to_cas(VALUE num)
 {
-  return couchbase::cas{ static_cast<std::uint64_t>(NUM2ULL(num)) };
+  return couchbase::cas{ static_cast<std::uint64_t>(cb_num2ull(num)) };
 }
 
 VALUE
@@ -370,7 +399,7 @@ cb_extract_cas(couchbase::cas& field, VALUE cas)
       break;
     default:
       throw couchbase::ruby::ruby_exception(
-        rb_eArgError, rb_sprintf("CAS must be an Integer, but given %+" PRIsVALUE, cas));
+        rb_eArgError, cb_sprintf("CAS must be an Integer, but given %+" PRIsVALUE, cas));
   }
 }
 
@@ -380,7 +409,7 @@ cb_extract_expiry(std::uint32_t& field, VALUE options)
   if (NIL_P(options)) {
     return;
   }
-  Check_Type(options, T_HASH);
+  cb_check_type(options, T_HASH);
 
   static VALUE property_name = rb_id2sym(rb_intern("expiry"));
   VALUE val = rb_hash_aref(options, property_name);
@@ -408,7 +437,7 @@ cb_extract_expiry(std::optional<std::uint32_t>& field, VALUE options)
   if (NIL_P(options)) {
     return;
   }
-  Check_Type(options, T_HASH);
+  cb_check_type(options, T_HASH);
 
   static VALUE property_name = rb_id2sym(rb_intern("expiry"));
   VALUE val = rb_hash_aref(options, property_name);
@@ -434,12 +463,12 @@ std::pair<expiry_type, std::chrono::seconds>
 unpack_expiry(VALUE val, bool allow_nil)
 {
   if (TYPE(val) == T_FIXNUM || TYPE(val) == T_BIGNUM) {
-    return { expiry_type::relative, std::chrono::seconds(NUM2ULL(val)) };
+    return { expiry_type::relative, std::chrono::seconds(cb_num2ull(val)) };
   }
   if (TYPE(val) != T_ARRAY || RARRAY_LEN(val) != 2) {
     throw ruby_exception(
       rb_eArgError,
-      rb_sprintf("expected expiry to be Array[Symbol, Integer|nil], given %+" PRIsVALUE, val));
+      cb_sprintf("expected expiry to be Array[Symbol, Integer|nil], given %+" PRIsVALUE, val));
   }
   VALUE expiry = rb_ary_entry(val, 1);
   if (NIL_P(expiry)) {
@@ -450,14 +479,14 @@ unpack_expiry(VALUE val, bool allow_nil)
   }
   if (TYPE(expiry) != T_FIXNUM && TYPE(expiry) != T_BIGNUM) {
     throw ruby_exception(
-      rb_eArgError, rb_sprintf("expiry value must be an Integer, but given %+" PRIsVALUE, expiry));
+      rb_eArgError, cb_sprintf("expiry value must be an Integer, but given %+" PRIsVALUE, expiry));
   }
-  auto duration = std::chrono::seconds(NUM2ULL(expiry));
+  auto duration = std::chrono::seconds(cb_num2ull(expiry));
 
   VALUE type = rb_ary_entry(val, 0);
   if (TYPE(type) != T_SYMBOL) {
     throw ruby_exception(rb_eArgError,
-                         rb_sprintf("expiry type must be a Symbol, but given %+" PRIsVALUE, type));
+                         cb_sprintf("expiry type must be a Symbol, but given %+" PRIsVALUE, type));
   }
   static VALUE duration_type = rb_id2sym(rb_intern("duration"));
   static VALUE time_point_type = rb_id2sym(rb_intern("time_point"));
@@ -467,7 +496,7 @@ unpack_expiry(VALUE val, bool allow_nil)
   if (type == time_point_type) {
     return { expiry_type::absolute, duration };
   }
-  throw ruby_exception(rb_eArgError, rb_sprintf("unknown expiry type: %+" PRIsVALUE, type));
+  throw ruby_exception(rb_eArgError, cb_sprintf("unknown expiry type: %+" PRIsVALUE, type));
 }
 
 std::optional<couchbase::durability_level>
@@ -475,7 +504,7 @@ extract_durability_level(VALUE options)
 {
   static VALUE property_name{ rb_id2sym(rb_intern("durability_level")) };
   if (VALUE val = rb_hash_aref(options, property_name); !NIL_P(val)) {
-    ID level = rb_sym2id(val);
+    ID level = cb_sym2id(val);
     if (level == rb_intern("none")) {
       return {};
     }
@@ -489,7 +518,7 @@ extract_durability_level(VALUE options)
       return couchbase::durability_level::persist_to_majority;
     }
     throw ruby_exception(exc_invalid_argument(),
-                         rb_sprintf("unknown durability level: %+" PRIsVALUE, val));
+                         cb_sprintf("unknown durability level: %+" PRIsVALUE, val));
   }
   return couchbase::durability_level::none;
 }
@@ -527,7 +556,7 @@ get_bool(VALUE options, VALUE name)
       default:
         throw ruby_exception(
           rb_eArgError,
-          rb_sprintf("%+" PRIsVALUE " must be a Boolean, but given %+" PRIsVALUE, name, val));
+          cb_sprintf("%+" PRIsVALUE " must be a Boolean, but given %+" PRIsVALUE, name, val));
     }
   }
   return {};
@@ -546,11 +575,11 @@ get_milliseconds(VALUE options, VALUE name)
       case T_FIXNUM:
         return std::chrono::milliseconds(FIX2ULONG(val));
       case T_BIGNUM:
-        return std::chrono::milliseconds(NUM2ULL(val));
+        return std::chrono::milliseconds(cb_num2ull(val));
       default:
         throw ruby_exception(
           rb_eArgError,
-          rb_sprintf("%+" PRIsVALUE
+          cb_sprintf("%+" PRIsVALUE
                      " must be a Integer representing milliseconds, but given %+" PRIsVALUE,
                      name,
                      val));
@@ -572,11 +601,11 @@ get_size_t(VALUE options, VALUE name)
       case T_FIXNUM:
         return static_cast<std::size_t>(FIX2ULONG(val));
       case T_BIGNUM:
-        return static_cast<std::size_t>(NUM2ULL(val));
+        return static_cast<std::size_t>(cb_num2ull(val));
       default:
         throw ruby_exception(
           rb_eArgError,
-          rb_sprintf("%+" PRIsVALUE " must be a Integer, but given %+" PRIsVALUE, name, val));
+          cb_sprintf("%+" PRIsVALUE " must be a Integer, but given %+" PRIsVALUE, name, val));
     }
   }
   return {};
@@ -596,26 +625,26 @@ get_uint16_t(VALUE options, VALUE name)
         if (FIX2ULONG(val) > std::numeric_limits<std::uint16_t>::max()) {
           throw ruby_exception(
             rb_eArgError,
-            rb_sprintf("%+" PRIsVALUE " must not be larger than %d , but given %+" PRIsVALUE,
+            cb_sprintf("%+" PRIsVALUE " must not be larger than %d , but given %+" PRIsVALUE,
                        name,
                        static_cast<int>(std::numeric_limits<std::uint16_t>::max()),
                        val));
         }
         return static_cast<std::uint16_t>(FIX2ULONG(val));
       case T_BIGNUM:
-        if (NUM2ULL(val) > std::numeric_limits<std::uint16_t>::max()) {
+        if (cb_num2ull(val) > std::numeric_limits<std::uint16_t>::max()) {
           throw ruby_exception(
             rb_eArgError,
-            rb_sprintf("%+" PRIsVALUE " must not be larger than %d , but given %+" PRIsVALUE,
+            cb_sprintf("%+" PRIsVALUE " must not be larger than %d , but given %+" PRIsVALUE,
                        name,
                        static_cast<int>(std::numeric_limits<std::uint16_t>::max()),
                        val));
         }
-        return static_cast<std::uint16_t>(NUM2ULL(val));
+        return static_cast<std::uint16_t>(cb_num2ull(val));
       default:
         throw ruby_exception(
           rb_eArgError,
-          rb_sprintf("%+" PRIsVALUE " must be a Integer, but given %+" PRIsVALUE, name, val));
+          cb_sprintf("%+" PRIsVALUE " must be a Integer, but given %+" PRIsVALUE, name, val));
     }
   }
   return {};
@@ -635,7 +664,7 @@ get_symbol(VALUE options, VALUE name)
     }
     throw couchbase::ruby::ruby_exception(
       rb_eArgError,
-      rb_sprintf("%+" PRIsVALUE " must be an Symbol, but given %+" PRIsVALUE, name, val));
+      cb_sprintf("%+" PRIsVALUE " must be an Symbol, but given %+" PRIsVALUE, name, val));
   }
   return {};
 }
@@ -654,7 +683,7 @@ get_hash(VALUE options, VALUE name)
     }
     throw couchbase::ruby::ruby_exception(
       rb_eArgError,
-      rb_sprintf("%+" PRIsVALUE " must be a Hash, but given %+" PRIsVALUE, name, val));
+      cb_sprintf("%+" PRIsVALUE " must be a Hash, but given %+" PRIsVALUE, name, val));
   }
   return {};
 }
@@ -673,9 +702,43 @@ get_string(VALUE options, VALUE name)
     }
     throw couchbase::ruby::ruby_exception(
       rb_eArgError,
-      rb_sprintf("%+" PRIsVALUE " must be an String, but given %+" PRIsVALUE, name, val));
+      cb_sprintf("%+" PRIsVALUE " must be an String, but given %+" PRIsVALUE, name, val));
   }
   return {};
 }
 } // namespace options
+
+auto
+cb_to_timeout(VALUE timeout, const char* name, std::chrono::milliseconds max_timeout)
+  -> std::chrono::milliseconds
+{
+  if (!RB_INTEGER_TYPE_P(timeout)) {
+    VALUE message = Qnil;
+    cb_protect([&message, timeout, name] {
+      message = rb_sprintf("%s must be an Integer, but given %+" PRIsVALUE, name, timeout);
+    });
+    throw ruby_exception(rb_eArgError, message);
+  }
+  std::uint64_t timeout_ms = 0;
+  // The sign is -2 or -1 for a negative value, and 2 for one that does not fit timeout_ms.
+  if (int sign = rb_integer_pack(timeout,
+                                 &timeout_ms,
+                                 1,
+                                 sizeof(timeout_ms),
+                                 0,
+                                 INTEGER_PACK_LSWORD_FIRST | INTEGER_PACK_NATIVE_BYTE_ORDER);
+      sign < 0 || sign > 1 || timeout_ms > static_cast<std::uint64_t>(max_timeout.count())) {
+    VALUE message = Qnil;
+    cb_protect([&message, timeout, name, max = static_cast<std::int64_t>(max_timeout.count())] {
+      message =
+        rb_sprintf("%s must be between 0 and %" PRId64 " milliseconds, but given %+" PRIsVALUE,
+                   name,
+                   max,
+                   timeout);
+    });
+    throw ruby_exception(exc_invalid_argument(), message);
+  }
+  return std::chrono::milliseconds{ static_cast<std::int64_t>(timeout_ms) };
+}
+
 } // namespace couchbase::ruby