couchbase 3.8.2 → 3.9.0

data/ext/rcb_hdr_histogram.cxx

@@ -161,15 +161,30 @@ cb_HdrHistogramC_get_percentiles_and_reset(VALUE self, VALUE percentiles)
   cb_hdr_histogram_data* hdr_histogram;
   TypedData_Get_Struct(self, cb_hdr_histogram_data, &cb_hdr_histogram_type, hdr_histogram);
 
+  // Validate before any C++ object is live and before taking the lock: a raise longjmps past
+  // destructors, so a raise under the lock would leave the mutex locked.
+  const long percentiles_len = RARRAY_LEN(percentiles);
+  for (long i = 0; i < percentiles_len; ++i) {
+    VALUE entry = rb_ary_entry(percentiles, i);
+    if (!RB_FLOAT_TYPE_P(entry) && !RB_INTEGER_TYPE_P(entry)) {
+      rb_raise(rb_eTypeError,
+               "wrong argument type %" PRIsVALUE " (expected Float or Integer)",
+               rb_obj_class(entry));
+    }
+  }
+  std::vector<double> percentile_args{};
+  percentile_args.reserve(static_cast<std::size_t>(percentiles_len));
+  for (long i = 0; i < percentiles_len; ++i) {
+    percentile_args.push_back(NUM2DBL(rb_ary_entry(percentiles, i)));
+  }
+
   std::vector<std::int64_t> percentile_values{};
+  percentile_values.reserve(percentile_args.size());
   std::int64_t total_count;
   {
     const std::unique_lock lock(hdr_histogram->mutex);
     total_count = hdr_histogram->histogram->total_count;
-    for (std::size_t i = 0; i < static_cast<std::size_t>(RARRAY_LEN(percentiles)); ++i) {
-      VALUE entry = rb_ary_entry(percentiles, static_cast<long>(i));
-      Check_Type(entry, T_FLOAT);
-      double perc = NUM2DBL(entry);
+    for (const double perc : percentile_args) {
       std::int64_t value_at_perc = hdr_value_at_percentile(hdr_histogram->histogram, perc);
       percentile_values.push_back(value_at_perc);
     }

data/ext/rcb_logger.cxx

@@ -28,10 +28,14 @@
 #include <spdlog/sinks/base_sink.h>
 #include <spdlog/spdlog.h>
 
+#include <algorithm>
+#include <deque>
+#include <iterator>
 #include <memory>
-#include <queue>
+#include <mutex>
 
 #include <ruby.h>
+#include <ruby/vm.h>
 
 #include "rcb_logger.hxx"
 #include "rcb_utils.hxx"
@@ -49,14 +53,59 @@ public:
   {
   }
 
-  void flush_deferred_messages()
+  // Returns the rb_protect state of the failed write, or zero. The caller jumps with it once its
+  // own C++ objects are destroyed.
+  int flush_deferred_messages()
   {
-    std::lock_guard<Mutex> lock(spdlog::sinks::base_sink<Mutex>::mutex_);
-    auto messages_ = std::move(deferred_messages_);
-    while (!messages_.empty()) {
-      write_message(messages_.front());
-      messages_.pop();
+    int state = 0;
+    {
+      // The mutex is held only to move messages in and out of the queue. A longjmp out of the
+      // Ruby logger would leave it locked, and a logger that releases the GVL would deadlock with
+      // a flush that holds the GVL and waits for the mutex.
+      std::deque<log_message_for_ruby> messages{};
+      {
+        std::lock_guard<Mutex> lock(spdlog::sinks::base_sink<Mutex>::mutex_);
+        std::swap(messages, deferred_messages_);
+      }
+      // install_logger_shim may replace @__logger_shim while the logger runs, which drops the last
+      // reference to it.
+      VALUE logger = ruby_logger_;
+      while (state == 0 && !messages.empty()) {
+        state = write_message(logger, messages.front());
+        // A message is retried once. An interrupt may land before its callback wrote it, and a
+        // logger that fails on it every time must not stop the queue.
+        if (state == 0 || messages.front().failed) {
+          messages.pop_front();
+        } else {
+          messages.front().failed = true;
+        }
+      }
+      RB_GC_GUARD(logger);
+      // After a failed write the unwritten messages go back to the front of the queue, ahead of
+      // those logged meanwhile. The caller's jump is not
+      // delayed by writing them, and rb_errinfo() is left as the failing callback set it.
+      if (!messages.empty()) {
+        std::lock_guard<Mutex> lock(spdlog::sinks::base_sink<Mutex>::mutex_);
+        std::move(
+          deferred_messages_.begin(), deferred_messages_.end(), std::back_inserter(messages));
+        std::swap(messages, deferred_messages_);
+      }
     }
+    return state;
+  }
+
+  // Moves the messages queued in other to the front of this sink's queue.
+  void take_deferred_messages(ruby_logger_sink& other)
+  {
+    if (&other == this) {
+      return;
+    }
+    std::scoped_lock lock(this->mutex_, other.mutex_);
+    std::move(deferred_messages_.begin(),
+              deferred_messages_.end(),
+              std::back_inserter(other.deferred_messages_));
+    std::swap(other.deferred_messages_, deferred_messages_);
+    other.deferred_messages_.clear();
   }
 
   static VALUE map_log_level(spdlog::level::level_enum level)
@@ -91,11 +140,12 @@ protected:
     const char* filename{ "<file>" };
     int line{};
     const char* funcname{ "<func>" };
+    bool failed{ false };
   };
 
   void sink_it_(const spdlog::details::log_msg& msg) override
   {
-    deferred_messages_.emplace(log_message_for_ruby{
+    deferred_messages_.emplace_back(log_message_for_ruby{
       msg.level,
       msg.time,
       msg.thread_id,
@@ -137,7 +187,8 @@ private:
       function_name = cb_str_new(msg.funcname);
     }
     auto seconds = std::chrono::duration_cast<std::chrono::seconds>(msg.time.time_since_epoch());
-    auto nanoseconds = msg.time.time_since_epoch() - seconds;
+    auto nanoseconds =
+      std::chrono::duration_cast<std::chrono::nanoseconds>(msg.time.time_since_epoch() - seconds);
     return rb_funcall(args->logger,
                       rb_intern("log"),
                       8,
@@ -151,18 +202,27 @@ private:
                       function_name);
   }
 
-  void write_message(const log_message_for_ruby& msg)
+  static VALUE invoke_log_rescue_standard_error(VALUE arg)
   {
-    if (NIL_P(ruby_logger_)) {
-      return;
+    return rb_rescue(invoke_log, arg, nullptr, Qnil);
+  }
+
+  // Returns the rb_protect state, non-zero when the logger call ended by a jump other than a
+  // rescued StandardError: another exception, a throw, or a thread kill.
+  static int write_message(VALUE logger, const log_message_for_ruby& msg)
+  {
+    if (NIL_P(logger)) {
+      return 0;
     }
-    argument_pack args{ ruby_logger_, msg };
+    argument_pack args{ logger, msg };
+    int state = 0;
     // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-    rb_rescue(invoke_log, reinterpret_cast<VALUE>(&args), nullptr, Qnil);
+    rb_protect(invoke_log_rescue_standard_error, reinterpret_cast<VALUE>(&args), &state);
+    return state;
   }
 
   VALUE ruby_logger_{ Qnil };
-  std::queue<log_message_for_ruby> deferred_messages_{};
+  std::deque<log_message_for_ruby> deferred_messages_{};
 };
 
 using ruby_logger_sink_ptr = std::shared_ptr<ruby_logger_sink<std::mutex>>;
@@ -226,15 +286,27 @@ cb_Backend_get_log_level(VALUE /* self */)
   return Qnil;
 }
 
-VALUE
-cb_Backend_install_logger_shim(VALUE self, VALUE logger, VALUE log_level)
+// Returns the rb_protect state of a failed flush, or zero. When sink is no longer the current
+// one, its unwritten messages move to the front of the current sink's queue, because a replaced
+// sink is never flushed again.
+int
+flush_sink(const ruby_logger_sink_ptr& sink)
 {
-  core::logger::reset();
+  int state = sink->flush_deferred_messages();
+  if (state != 0 && cb_global_sink && cb_global_sink != sink) {
+    cb_global_sink->take_deferred_messages(*sink);
+  }
+  return state;
+}
+
+void
+install_logger_sink(VALUE self, VALUE logger, VALUE log_level)
+{
+  cb_global_sink.reset();
   rb_iv_set(self, "@__logger_shim", logger);
   if (NIL_P(logger)) {
-    return Qnil;
+    return;
   }
-  Check_Type(log_level, T_SYMBOL);
   core::logger::level level{ core::logger::level::off };
   if (ID type = rb_sym2id(log_level); type == rb_intern("trace")) {
     level = core::logger::level::trace;
@@ -249,8 +321,8 @@ cb_Backend_install_logger_shim(VALUE self, VALUE logger, VALUE log_level)
   } else if (type == rb_intern("critical")) {
     level = core::logger::level::critical;
   } else {
-    rb_iv_set(self, "__logger_shim", Qnil);
-    return Qnil;
+    rb_iv_set(self, "@__logger_shim", Qnil);
+    return;
   }
 
   auto sink = std::make_shared<ruby_logger_sink<std::mutex>>(logger);
@@ -260,6 +332,26 @@ cb_Backend_install_logger_shim(VALUE self, VALUE logger, VALUE log_level)
   configuration.sink = sink;
   core::logger::create_file_logger(configuration);
   cb_global_sink = sink;
+}
+
+VALUE
+cb_Backend_install_logger_shim(VALUE self, VALUE logger, VALUE log_level)
+{
+  if (!NIL_P(logger)) {
+    cb_check_type(log_level, T_SYMBOL);
+  }
+  VALUE old_logger = rb_iv_get(self, "@__logger_shim");
+  // The new sink is installed before the old one is flushed, so a failed flush leaves the new
+  // logger in place and hands it the old sink's unwritten messages. Without a new logger they
+  // have no destination.
+  auto old_sink = cb_global_sink;
+  core::logger::reset();
+  install_logger_sink(self, logger, log_level);
+  int state = old_sink ? flush_sink(old_sink) : 0;
+  RB_GC_GUARD(old_logger);
+  if (state != 0) {
+    throw ruby_jump(state);
+  }
   return Qnil;
 }
 
@@ -298,22 +390,105 @@ init_logger()
   }
 }
 
+int
+try_flush_logger()
+{
+  if (auto sink = cb_global_sink; sink) {
+    return flush_sink(sink);
+  }
+  core::logger::flush();
+  return 0;
+}
+
 void
 flush_logger()
 {
-  if (cb_global_sink) {
-    cb_global_sink->flush_deferred_messages();
-  } else {
-    core::logger::flush();
+  if (int state = try_flush_logger(); state != 0) {
+    rb_jump_tag(state);
   }
 }
 
+int
+try_flush_logger_interruptible()
+{
+  int state = 0;
+  rb_protect(
+    [](VALUE) noexcept -> VALUE {
+      VALUE mask = rb_hash_new();
+      rb_hash_aset(mask, rb_cObject, rb_id2sym(rb_intern("immediate")));
+      return rb_block_call(
+        rb_cThread,
+        rb_intern("handle_interrupt"),
+        1,
+        &mask,
+        [](VALUE, VALUE, int, const VALUE*, VALUE) noexcept -> VALUE {
+          flush_logger();
+          return Qnil;
+        },
+        Qnil);
+    },
+    Qnil,
+    &state);
+  return state;
+}
+
+namespace
+{
+// Joins the async logger thread while it is still running. VM at-exit hooks
+// run after every end proc and finalizer, so what those log, such as a cluster
+// closed in its finalizer, still reaches the built-in sinks. Left to the spdlog
+// destructors, the join happens after ExitProcess has killed the thread. That
+// never returns under winpthreads, and the Ruby process hangs on Windows.
+void
+shutdown_logger(ruby_vm_t* /* vm */)
+{
+  core::logger::shutdown();
+}
+} // namespace
+
 void
 init_logger_methods(VALUE cBackend)
 {
+  // A failed flush leaves messages queued. At exit, flush again after a failure that is an
+  // ordinary exception; a message is consumed after its second failure, so the loop ends. A signal,
+  // exit, throw or thread kill stops the loop and is re-raised for the end-proc runner.
+  rb_set_end_proc(
+    [](VALUE) {
+      // The swallowed exception must not replace the $! the exit started with, which the logger
+      // sees on the next attempt. rb_set_errinfo accepts only nil or an Exception.
+      VALUE exit_error = rb_errinfo();
+      bool restorable = NIL_P(exit_error) || (RB_TYPE_P(exit_error, T_OBJECT) &&
+                                              RTEST(rb_obj_is_kind_of(exit_error, rb_eException)));
+      int state = 0;
+      for (;;) {
+        rb_protect(
+          [](VALUE) -> VALUE {
+            flush_logger();
+            return Qnil;
+          },
+          Qnil,
+          &state);
+        if (state != 0) {
+          VALUE error = rb_errinfo();
+          if (!RB_TYPE_P(error, T_OBJECT) || RTEST(rb_obj_is_kind_of(error, rb_eSignal)) ||
+              RTEST(rb_obj_is_kind_of(error, rb_eSystemExit))) {
+            rb_jump_tag(state);
+          }
+        }
+        if (restorable) {
+          rb_set_errinfo(exit_error);
+        }
+        if (state == 0) {
+          return;
+        }
+      }
+    },
+    Qnil);
+  ruby_vm_at_exit(shutdown_logger);
   rb_define_singleton_method(cBackend, "set_log_level", cb_Backend_set_log_level, 1);
   rb_define_singleton_method(cBackend, "get_log_level", cb_Backend_get_log_level, 0);
-  rb_define_singleton_method(cBackend, "install_logger_shim", cb_Backend_install_logger_shim, 2);
+  rb_define_singleton_method(
+    cBackend, "install_logger_shim", cb_method<cb_Backend_install_logger_shim>::invoke, 2);
   rb_define_singleton_method(cBackend,
                              "enable_protocol_logger_to_save_network_traffic_to_file",
                              cb_Backend_enable_protocol_logger_to_save_network_traffic_to_file,

data/ext/rcb_logger.hxx

@@ -31,6 +31,18 @@ init_logger();
 void
 flush_logger();
 
+// Flushes like flush_logger, but returns the rb_protect state of a failed logger call instead of
+// re-raising it. The caller jumps with it once its own C++ objects are destroyed.
+int
+try_flush_logger();
+
+// Like try_flush_logger, but accepts asynchronous interrupts while the logger runs, even inside
+// Thread.handle_interrupt(Object => :never). An interrupt delivered there ends the flush as a
+// failed logger call and is returned as its rb_protect state. One deferred before the call is
+// delivered at the first logger call, and stays deferred when nothing is queued.
+int
+try_flush_logger_interruptible();
+
 void
 init_logger_methods(VALUE cBackend);
 

data/ext/rcb_multi.cxx

@@ -51,7 +51,7 @@ cb_extract_array_of_ids(std::vector<core::document_id>& ids, VALUE arg)
   if (TYPE(arg) != T_ARRAY) {
     throw ruby_exception(
       rb_eArgError,
-      rb_sprintf("Type of IDs argument must be an Array, but given %+" PRIsVALUE, arg));
+      cb_sprintf("Type of IDs argument must be an Array, but given %+" PRIsVALUE, arg));
   }
   auto num_of_ids = static_cast<std::size_t>(RARRAY_LEN(arg));
   if (num_of_ids < 1) {
@@ -62,30 +62,30 @@ cb_extract_array_of_ids(std::vector<core::document_id>& ids, VALUE arg)
     VALUE entry = rb_ary_entry(arg, static_cast<long>(i));
     if (TYPE(entry) != T_ARRAY || RARRAY_LEN(entry) != 4) {
       throw ruby_exception(rb_eArgError,
-                           rb_sprintf("ID tuple must be represented as an Array[bucket, scope, "
+                           cb_sprintf("ID tuple must be represented as an Array[bucket, scope, "
                                       "collection, id], but given %+" PRIsVALUE,
                                       entry));
     }
     VALUE bucket = rb_ary_entry(entry, 0);
     if (TYPE(bucket) != T_STRING) {
       throw ruby_exception(rb_eArgError,
-                           rb_sprintf("Bucket must be a String, but given %+" PRIsVALUE, bucket));
+                           cb_sprintf("Bucket must be a String, but given %+" PRIsVALUE, bucket));
     }
     VALUE scope = rb_ary_entry(entry, 1);
     if (TYPE(scope) != T_STRING) {
       throw ruby_exception(rb_eArgError,
-                           rb_sprintf("Scope must be a String, but given %+" PRIsVALUE, scope));
+                           cb_sprintf("Scope must be a String, but given %+" PRIsVALUE, scope));
     }
     VALUE collection = rb_ary_entry(entry, 2);
     if (TYPE(collection) != T_STRING) {
       throw ruby_exception(
         rb_eArgError,
-        rb_sprintf("Collection must be a String, but given %+" PRIsVALUE, collection));
+        cb_sprintf("Collection must be a String, but given %+" PRIsVALUE, collection));
     }
     VALUE id = rb_ary_entry(entry, 3);
     if (TYPE(id) != T_STRING) {
       throw ruby_exception(rb_eArgError,
-                           rb_sprintf("ID must be a String, but given %+" PRIsVALUE, id));
+                           cb_sprintf("ID must be a String, but given %+" PRIsVALUE, id));
     }
     ids.emplace_back(
       cb_string_new(bucket), cb_string_new(scope), cb_string_new(collection), cb_string_new(id));
@@ -107,7 +107,7 @@ cb_extract_array_of_id_content(
   if (TYPE(tuples) != T_ARRAY) {
     throw ruby_exception(
       rb_eArgError,
-      rb_sprintf("Type of ID/content tuples must be an Array, but given %+" PRIsVALUE, tuples));
+      cb_sprintf("Type of ID/content tuples must be an Array, but given %+" PRIsVALUE, tuples));
   }
 
   auto num_of_tuples = static_cast<std::size_t>(RARRAY_LEN(tuples));
@@ -119,24 +119,24 @@ cb_extract_array_of_id_content(
     VALUE entry = rb_ary_entry(tuples, static_cast<long>(i));
     if (TYPE(entry) != T_ARRAY || RARRAY_LEN(entry) != 3) {
       throw ruby_exception(rb_eArgError,
-                           rb_sprintf("ID/content tuple must be represented as an Array[id, "
+                           cb_sprintf("ID/content tuple must be represented as an Array[id, "
                                       "content, flags], but given %+" PRIsVALUE,
                                       entry));
     }
     VALUE id = rb_ary_entry(entry, 0);
     if (TYPE(id) != T_STRING) {
       throw ruby_exception(rb_eArgError,
-                           rb_sprintf("ID must be a String, but given %+" PRIsVALUE, id));
+                           cb_sprintf("ID must be a String, but given %+" PRIsVALUE, id));
     }
     VALUE content = rb_ary_entry(entry, 1);
     if (TYPE(content) != T_STRING) {
       throw ruby_exception(rb_eArgError,
-                           rb_sprintf("Content must be a String, but given %+" PRIsVALUE, content));
+                           cb_sprintf("Content must be a String, but given %+" PRIsVALUE, content));
     }
     VALUE flags = rb_ary_entry(entry, 2);
     if (TYPE(flags) != T_FIXNUM) {
       throw ruby_exception(rb_eArgError,
-                           rb_sprintf("Flags must be an Integer, but given %+" PRIsVALUE, flags));
+                           cb_sprintf("Flags must be an Integer, but given %+" PRIsVALUE, flags));
     }
     id_content.emplace_back(core::document_id{ cb_string_new(bucket_name),
                                                cb_string_new(scope_name),
@@ -144,7 +144,7 @@ cb_extract_array_of_id_content(
                                                cb_string_new(id) },
                             couchbase::codec::encoded_value{
                               cb_binary_new(content),
-                              FIX2UINT(flags),
+                              cb_num2uint(flags),
                             });
   }
 }
@@ -163,11 +163,11 @@ cb_extract_array_of_id_cas(std::vector<std::pair<core::document_id, couchbase::c
   if (TYPE(tuples) != T_ARRAY) {
     throw ruby_exception(
       rb_eArgError,
-      rb_sprintf("Type of ID/CAS tuples must be an Array, but given %+" PRIsVALUE, tuples));
+      cb_sprintf("Type of ID/CAS tuples must be an Array, but given %+" PRIsVALUE, tuples));
   }
   auto num_of_tuples = static_cast<std::size_t>(RARRAY_LEN(tuples));
   if (num_of_tuples < 1) {
-    rb_raise(rb_eArgError, "Array of ID/CAS tuples must not be empty");
+    throw ruby_exception(rb_eArgError, "Array of ID/CAS tuples must not be empty");
   }
   id_cas.reserve(num_of_tuples);
   for (std::size_t i = 0; i < num_of_tuples; ++i) {
@@ -175,14 +175,14 @@ cb_extract_array_of_id_cas(std::vector<std::pair<core::document_id, couchbase::c
     if (TYPE(entry) != T_ARRAY || RARRAY_LEN(entry) != 2) {
       throw ruby_exception(
         rb_eArgError,
-        rb_sprintf(
+        cb_sprintf(
           "ID/content tuple must be represented as an Array[id, CAS], but given %+" PRIsVALUE,
           entry));
     }
     VALUE id = rb_ary_entry(entry, 0);
     if (TYPE(id) != T_STRING) {
       throw ruby_exception(rb_eArgError,
-                           rb_sprintf("ID must be a String, but given %+" PRIsVALUE, id));
+                           cb_sprintf("ID must be a String, but given %+" PRIsVALUE, id));
     }
     couchbase::cas cas_val{};
     if (VALUE cas = rb_ary_entry(entry, 1); !NIL_P(cas)) {
@@ -205,6 +205,7 @@ cb_Backend_document_get_multi(VALUE self, VALUE keys, VALUE options)
   try {
     std::chrono::milliseconds timeout{ 0 };
     cb_extract_timeout(timeout, options);
+    auto retry_strategy = cb_extract_retry_strategy(options);
 
     std::vector<core::document_id> ids{};
     cb_extract_array_of_ids(ids, keys);
@@ -214,7 +215,7 @@ cb_Backend_document_get_multi(VALUE self, VALUE keys, VALUE options)
     futures.reserve(num_of_ids);
 
     for (auto& id : ids) {
-      core::operations::get_request req{ std::move(id) };
+      core::operations::get_request req{ std::move(id), {}, {}, {}, { retry_strategy } };
       if (timeout.count() > 0) {
         req.timeout = timeout;
       }
@@ -243,10 +244,8 @@ cb_Backend_document_get_multi(VALUE self, VALUE keys, VALUE options)
 
     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;
 }
@@ -261,16 +260,17 @@ cb_Backend_document_upsert_multi(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
     std::vector<std::pair<core::document_id, couchbase::codec::encoded_value>> tuples{};
     cb_extract_array_of_id_content(tuples, bucket, scope, collection, id_content);
+    auto retry_strategy = cb_extract_retry_strategy(options);
 
     auto num_of_tuples = tuples.size();
     std::vector<std::pair<std::string, std::future<core::operations::upsert_response>>> futures;
@@ -278,8 +278,8 @@ cb_Backend_document_upsert_multi(VALUE self,
 
     for (auto& [id, content] : tuples) {
       core::operations::upsert_request req{
-        id,
-        std::move(content.data),
+        id, std::move(content.data), {}, {}, 0, 0, couchbase::durability_level::none,
+        {}, { retry_strategy },
       };
       req.flags = content.flags;
       cb_extract_timeout(req, options);
@@ -326,10 +326,8 @@ cb_Backend_document_upsert_multi(VALUE self,
     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;
 }
@@ -344,16 +342,17 @@ cb_Backend_document_remove_multi(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
-  Check_Type(scope, T_STRING);
-  Check_Type(collection, T_STRING);
+  cb_check_type(bucket, T_STRING);
+  cb_check_type(scope, T_STRING);
+  cb_check_type(collection, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
     std::vector<std::pair<core::document_id, couchbase::cas>> tuples{};
     cb_extract_array_of_id_cas(tuples, bucket, scope, collection, id_cas);
+    auto retry_strategy = cb_extract_retry_strategy(options);
 
     auto num_of_tuples = tuples.size();
     std::vector<std::pair<std::string, std::future<core::operations::remove_response>>> futures;
@@ -361,7 +360,7 @@ cb_Backend_document_remove_multi(VALUE self,
 
     for (const auto& [id, cas] : tuples) {
       core::operations::remove_request req{
-        id,
+        id, {}, {}, {}, couchbase::durability_level::none, {}, { retry_strategy },
       };
       cb_extract_timeout(req, options);
       cb_extract_durability_level(req, options);
@@ -406,10 +405,8 @@ cb_Backend_document_remove_multi(VALUE self,
     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;
 }
@@ -419,8 +416,11 @@ cb_Backend_document_remove_multi(VALUE self,
 void
 init_multi(VALUE cBackend)
 {
-  rb_define_method(cBackend, "document_get_multi", cb_Backend_document_get_multi, 2);
-  rb_define_method(cBackend, "document_remove_multi", cb_Backend_document_remove_multi, 5);
-  rb_define_method(cBackend, "document_upsert_multi", cb_Backend_document_upsert_multi, 5);
+  rb_define_method(
+    cBackend, "document_get_multi", cb_method<cb_Backend_document_get_multi>::invoke, 2);
+  rb_define_method(
+    cBackend, "document_remove_multi", cb_method<cb_Backend_document_remove_multi>::invoke, 5);
+  rb_define_method(
+    cBackend, "document_upsert_multi", cb_method<cb_Backend_document_upsert_multi>::invoke, 5);
 }
 } // namespace couchbase::ruby

data/ext/rcb_observability.cxx

@@ -89,11 +89,13 @@ cb_add_core_spans(VALUE observability_handler,
     rb_ary_push(spans, core_span_to_rb_hash(child));
   }
 
-  static ID add_backend_spans_func = rb_intern("add_spans_from_backend");
-  rb_funcall(observability_handler, add_backend_spans_func, 1, spans);
+  cb_protect([observability_handler, spans, retry_attempts] {
+    static ID add_backend_spans_func = rb_intern("add_spans_from_backend");
+    rb_funcall(observability_handler, add_backend_spans_func, 1, spans);
 
-  static ID add_retries_func = rb_intern("add_retries");
-  rb_funcall(observability_handler, add_retries_func, 1, ULONG2NUM(retry_attempts));
+    static ID add_retries_func = rb_intern("add_retries");
+    rb_funcall(observability_handler, add_retries_func, 1, ULONG2NUM(retry_attempts));
+  });
 }
 
 namespace
@@ -127,6 +129,6 @@ cb_Backend_cluster_labels(VALUE self)
 void
 init_observability(VALUE cBackend)
 {
-  rb_define_method(cBackend, "cluster_labels", cb_Backend_cluster_labels, 0);
+  rb_define_method(cBackend, "cluster_labels", cb_method<cb_Backend_cluster_labels>::invoke, 0);
 }
 } // namespace couchbase::ruby