couchbase 3.8.1 → 3.9.0

data/ext/rcb_analytics.cxx

@@ -87,10 +87,8 @@ cb_Backend_analytics_get_pending_mutations(VALUE self, VALUE options, VALUE obse
     }
     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;
 }
@@ -135,10 +133,8 @@ cb_Backend_analytics_dataset_get_all(VALUE self, VALUE options, VALUE observabil
     }
     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;
 }
@@ -151,7 +147,7 @@ cb_Backend_analytics_dataset_drop(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(dataset_name, T_STRING);
+  cb_check_type(dataset_name, T_STRING);
 
   try {
     core::operations::management::analytics_dataset_drop_request req{};
@@ -192,10 +188,8 @@ cb_Backend_analytics_dataset_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;
 }
@@ -209,8 +203,8 @@ cb_Backend_analytics_dataset_create(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(dataset_name, T_STRING);
-  Check_Type(bucket_name, T_STRING);
+  cb_check_type(dataset_name, T_STRING);
+  cb_check_type(bucket_name, T_STRING);
 
   try {
     core::operations::management::analytics_dataset_create_request req{};
@@ -247,10 +241,8 @@ cb_Backend_analytics_dataset_create(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;
 }
@@ -263,7 +255,7 @@ cb_Backend_analytics_dataverse_drop(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(dataverse_name, T_STRING);
+  cb_check_type(dataverse_name, T_STRING);
 
   try {
     core::operations::management::analytics_dataverse_drop_request req{};
@@ -292,10 +284,8 @@ cb_Backend_analytics_dataverse_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;
 }
@@ -308,9 +298,9 @@ cb_Backend_analytics_dataverse_create(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(dataverse_name, T_STRING);
+  cb_check_type(dataverse_name, T_STRING);
   if (!NIL_P(dataverse_name)) {
-    Check_Type(dataverse_name, T_STRING);
+    cb_check_type(dataverse_name, T_STRING);
   }
 
   try {
@@ -341,10 +331,8 @@ cb_Backend_analytics_dataverse_create(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;
 }
@@ -387,10 +375,8 @@ cb_Backend_analytics_index_get_all(VALUE self, VALUE options, VALUE observabilit
     }
     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;
 }
@@ -405,9 +391,9 @@ cb_Backend_analytics_index_create(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(index_name, T_STRING);
-  Check_Type(dataset_name, T_STRING);
-  Check_Type(fields, T_ARRAY);
+  cb_check_type(index_name, T_STRING);
+  cb_check_type(dataset_name, T_STRING);
+  cb_check_type(fields, T_ARRAY);
 
   try {
     core::operations::management::analytics_index_create_request req{};
@@ -417,7 +403,7 @@ cb_Backend_analytics_index_create(VALUE self,
     auto fields_num = static_cast<std::size_t>(RARRAY_LEN(fields));
     for (std::size_t i = 0; i < fields_num; ++i) {
       VALUE entry = rb_ary_entry(fields, static_cast<long>(i));
-      Check_Type(entry, T_ARRAY);
+      cb_check_type(entry, T_ARRAY);
       if (RARRAY_LEN(entry) == 2) {
         VALUE field = rb_ary_entry(entry, 0);
         VALUE type = rb_ary_entry(entry, 1);
@@ -457,10 +443,8 @@ cb_Backend_analytics_index_create(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;
 }
@@ -474,8 +458,8 @@ cb_Backend_analytics_index_drop(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(index_name, T_STRING);
-  Check_Type(dataset_name, T_STRING);
+  cb_check_type(index_name, T_STRING);
+  cb_check_type(dataset_name, T_STRING);
 
   try {
     core::operations::management::analytics_index_drop_request req{};
@@ -512,10 +496,8 @@ cb_Backend_analytics_index_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;
 }
@@ -558,10 +540,8 @@ cb_Backend_analytics_link_connect(VALUE self, VALUE options, 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;
 }
@@ -603,10 +583,8 @@ cb_Backend_analytics_link_disconnect(VALUE self, VALUE options, 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;
 }
@@ -667,13 +645,13 @@ cb_Backend_analytics_link_create(VALUE self, VALUE link, VALUE options, VALUE ob
   auto cluster = cb_backend_to_core_api_cluster(self);
 
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
     VALUE link_type = Qnil;
     cb_extract_option_symbol(link_type, link, "type");
-    if (ID type = rb_sym2id(link_type); type == rb_intern("couchbase")) {
+    if (ID type = cb_sym2id(link_type); type == rb_intern("couchbase")) {
       core::operations::management::analytics_link_create_request<
         core::management::analytics::couchbase_remote_link>
         req{};
@@ -782,10 +760,8 @@ cb_Backend_analytics_link_create(VALUE self, VALUE link, VALUE options, VALUE ob
 
     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;
 }
@@ -799,14 +775,14 @@ cb_Backend_analytics_link_replace(VALUE self,
   auto cluster = cb_backend_to_core_api_cluster(self);
 
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
     VALUE link_type = Qnil;
     cb_extract_option_symbol(link_type, link, "type");
 
-    if (ID type = rb_sym2id(link_type); type == rb_intern("couchbase")) {
+    if (ID type = cb_sym2id(link_type); type == rb_intern("couchbase")) {
       core::operations::management::analytics_link_replace_request<
         core::management::analytics::couchbase_remote_link>
         req{};
@@ -916,10 +892,8 @@ cb_Backend_analytics_link_replace(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;
 }
@@ -933,10 +907,10 @@ cb_Backend_analytics_link_drop(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(link, T_STRING);
-  Check_Type(dataverse, T_STRING);
+  cb_check_type(link, T_STRING);
+  cb_check_type(dataverse, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -975,10 +949,8 @@ cb_Backend_analytics_link_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;
 }
@@ -989,7 +961,7 @@ cb_Backend_analytics_link_get_all(VALUE self, VALUE options, VALUE observability
   auto cluster = cb_backend_to_core_api_cluster(self);
 
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -1082,10 +1054,8 @@ cb_Backend_analytics_link_get_all(VALUE self, VALUE options, VALUE observability
 
     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;
 }
@@ -1121,17 +1091,6 @@ cb_analytics_status_str(core::operations::analytics_response::analytics_status s
   return "unknown";
 }
 
-int
-cb_for_each_named_param_analytics(VALUE key, VALUE value, VALUE arg)
-{
-  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-  auto* preq = reinterpret_cast<core::operations::analytics_request*>(arg);
-  cb_check_type(key, T_STRING);
-  cb_check_type(value, T_STRING);
-  preq->named_parameters[cb_string_new(key)] = cb_string_new(value);
-  return ST_CONTINUE;
-}
-
 VALUE
 cb_Backend_document_analytics(VALUE self,
                               VALUE statement,
@@ -1140,9 +1099,9 @@ cb_Backend_document_analytics(VALUE self,
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(statement, T_STRING);
+  cb_check_type(statement, T_STRING);
   if (!NIL_P(options)) {
-    Check_Type(options, T_HASH);
+    cb_check_type(options, T_HASH);
   }
 
   try {
@@ -1171,9 +1130,7 @@ cb_Backend_document_analytics(VALUE self,
     if (VALUE named_params = rb_hash_aref(options, rb_id2sym(rb_intern("named_parameters")));
         !NIL_P(named_params)) {
       cb_check_type(named_params, T_HASH);
-      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-      rb_hash_foreach(
-        named_params, cb_for_each_named_param_analytics, reinterpret_cast<VALUE>(&req));
+      cb_extract_string_hash(req.named_parameters, named_params, "named_parameters");
     }
     if (VALUE scan_consistency = rb_hash_aref(options, rb_id2sym(rb_intern("scan_consistency")));
         !NIL_P(scan_consistency)) {
@@ -1206,8 +1163,7 @@ cb_Backend_document_analytics(VALUE self,
     if (VALUE raw_params = rb_hash_aref(options, rb_id2sym(rb_intern("raw_parameters")));
         !NIL_P(raw_params)) {
       cb_check_type(raw_params, T_HASH);
-      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
-      rb_hash_foreach(raw_params, cb_for_each_named_param_analytics, reinterpret_cast<VALUE>(&req));
+      cb_extract_string_hash(req.raw, raw_params, "raw_parameters");
     }
 
     auto parent_span = cb_create_parent_span(req, self);
@@ -1268,10 +1224,8 @@ cb_Backend_document_analytics(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;
 }
@@ -1281,25 +1235,51 @@ cb_Backend_document_analytics(VALUE self,
 void
 init_analytics(VALUE cBackend)
 {
-  rb_define_method(cBackend, "document_analytics", cb_Backend_document_analytics, 3);
+  rb_define_method(
+    cBackend, "document_analytics", cb_method<cb_Backend_document_analytics>::invoke, 3);
 
   // Management APIs
+  rb_define_method(cBackend,
+                   "analytics_get_pending_mutations",
+                   cb_method<cb_Backend_analytics_get_pending_mutations>::invoke,
+                   2);
+  rb_define_method(cBackend,
+                   "analytics_dataverse_drop",
+                   cb_method<cb_Backend_analytics_dataverse_drop>::invoke,
+                   3);
+  rb_define_method(cBackend,
+                   "analytics_dataverse_create",
+                   cb_method<cb_Backend_analytics_dataverse_create>::invoke,
+                   3);
+  rb_define_method(cBackend,
+                   "analytics_dataset_create",
+                   cb_method<cb_Backend_analytics_dataset_create>::invoke,
+                   4);
+  rb_define_method(
+    cBackend, "analytics_dataset_drop", cb_method<cb_Backend_analytics_dataset_drop>::invoke, 3);
+  rb_define_method(cBackend,
+                   "analytics_dataset_get_all",
+                   cb_method<cb_Backend_analytics_dataset_get_all>::invoke,
+                   2);
+  rb_define_method(
+    cBackend, "analytics_index_get_all", cb_method<cb_Backend_analytics_index_get_all>::invoke, 2);
+  rb_define_method(
+    cBackend, "analytics_index_create", cb_method<cb_Backend_analytics_index_create>::invoke, 5);
+  rb_define_method(
+    cBackend, "analytics_index_drop", cb_method<cb_Backend_analytics_index_drop>::invoke, 4);
+  rb_define_method(
+    cBackend, "analytics_link_connect", cb_method<cb_Backend_analytics_link_connect>::invoke, 2);
+  rb_define_method(cBackend,
+                   "analytics_link_disconnect",
+                   cb_method<cb_Backend_analytics_link_disconnect>::invoke,
+                   2);
+  rb_define_method(
+    cBackend, "analytics_link_create", cb_method<cb_Backend_analytics_link_create>::invoke, 3);
+  rb_define_method(
+    cBackend, "analytics_link_replace", cb_method<cb_Backend_analytics_link_replace>::invoke, 3);
   rb_define_method(
-    cBackend, "analytics_get_pending_mutations", cb_Backend_analytics_get_pending_mutations, 2);
-  rb_define_method(cBackend, "analytics_dataverse_drop", cb_Backend_analytics_dataverse_drop, 3);
+    cBackend, "analytics_link_drop", cb_method<cb_Backend_analytics_link_drop>::invoke, 4);
   rb_define_method(
-    cBackend, "analytics_dataverse_create", cb_Backend_analytics_dataverse_create, 3);
-  rb_define_method(cBackend, "analytics_dataset_create", cb_Backend_analytics_dataset_create, 4);
-  rb_define_method(cBackend, "analytics_dataset_drop", cb_Backend_analytics_dataset_drop, 3);
-  rb_define_method(cBackend, "analytics_dataset_get_all", cb_Backend_analytics_dataset_get_all, 2);
-  rb_define_method(cBackend, "analytics_index_get_all", cb_Backend_analytics_index_get_all, 2);
-  rb_define_method(cBackend, "analytics_index_create", cb_Backend_analytics_index_create, 5);
-  rb_define_method(cBackend, "analytics_index_drop", cb_Backend_analytics_index_drop, 4);
-  rb_define_method(cBackend, "analytics_link_connect", cb_Backend_analytics_link_connect, 2);
-  rb_define_method(cBackend, "analytics_link_disconnect", cb_Backend_analytics_link_disconnect, 2);
-  rb_define_method(cBackend, "analytics_link_create", cb_Backend_analytics_link_create, 3);
-  rb_define_method(cBackend, "analytics_link_replace", cb_Backend_analytics_link_replace, 3);
-  rb_define_method(cBackend, "analytics_link_drop", cb_Backend_analytics_link_drop, 4);
-  rb_define_method(cBackend, "analytics_link_get_all", cb_Backend_analytics_link_get_all, 2);
+    cBackend, "analytics_link_get_all", cb_method<cb_Backend_analytics_link_get_all>::invoke, 2);
 }
 } // namespace couchbase::ruby

data/ext/rcb_backend.cxx

@@ -64,7 +64,8 @@ public:
     known_instances_.remove(instance);
   }
 
-  void notify_fork(couchbase::fork_event event)
+  // Returns the rb_protect state of a failed logger flush during prepare, or zero.
+  int notify_fork(couchbase::fork_event event)
   {
     if (event != couchbase::fork_event::prepare) {
       init_logger();
@@ -78,9 +79,18 @@ public:
     }
 
     if (event == couchbase::fork_event::prepare) {
-      flush_logger();
+      // The fork hook defers interrupts from :prepare until the fork, but a blocked logger must
+      // still be interruptible by Timeout or Thread#kill.
+      int state = try_flush_logger_interruptible();
       couchbase::core::logger::shutdown();
+      if (state != 0) {
+        // The fork does not happen, so the instances stopped above are restarted as in the
+        // parent of a completed fork.
+        notify_fork(couchbase::fork_event::parent);
+      }
+      return state;
     }
+    return 0;
   }
 
 private:
@@ -97,21 +107,22 @@ cb_Backend_notify_fork(VALUE self, VALUE event)
   static const auto id_parent{ rb_intern("parent") };
   static const auto id_child{ rb_intern("child") };
 
-  try {
-    cb_check_type(event, T_SYMBOL);
-
-    if (rb_sym2id(event) == id_prepare) {
-      instances.notify_fork(couchbase::fork_event::prepare);
-    } else if (rb_sym2id(event) == id_parent) {
-      instances.notify_fork(couchbase::fork_event::parent);
-    } else if (rb_sym2id(event) == id_child) {
-      instances.notify_fork(couchbase::fork_event::child);
-    } else {
-      throw ruby_exception(rb_eTypeError,
-                           rb_sprintf("unexpected fork event type %" PRIsVALUE "", event));
-    }
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
+  cb_check_type(event, T_SYMBOL);
+  int state = 0;
+  if (rb_sym2id(event) == id_prepare) {
+    state = instances.notify_fork(couchbase::fork_event::prepare);
+  } else if (rb_sym2id(event) == id_parent) {
+    instances.notify_fork(couchbase::fork_event::parent);
+  } else if (rb_sym2id(event) == id_child) {
+    instances.notify_fork(couchbase::fork_event::child);
+  } else {
+    throw ruby_exception(rb_eTypeError,
+                         cb_sprintf("unexpected fork event type %" PRIsVALUE "", event));
+  }
+  if (state != 0) {
+    // notify_fork has already restarted the instances. Only the interrupt check that ends
+    // Thread.handle_interrupt can have run Ruby code since the flush failed.
+    throw ruby_jump(state);
   }
 
   return Qnil;
@@ -308,7 +319,7 @@ initialize_cluster_options(const core::utils::connection_string& connstr,
     } else {
       throw ruby_exception(
         exc_invalid_argument(),
-        rb_sprintf("Failed to select verification mode for TLS: %+" PRIsVALUE, mode.value()));
+        cb_sprintf("Failed to select verification mode for TLS: %+" PRIsVALUE, mode.value()));
     }
   }
 
@@ -336,7 +347,7 @@ initialize_cluster_options(const core::utils::connection_string& connstr,
     } else {
       throw ruby_exception(
         exc_invalid_argument(),
-        rb_sprintf("Failed to setect preferred IP protocol: %+" PRIsVALUE, proto.value()));
+        cb_sprintf("Failed to setect preferred IP protocol: %+" PRIsVALUE, proto.value()));
     }
   }
 
@@ -497,12 +508,12 @@ cb_Backend_open(VALUE self, VALUE connstr, VALUE credentials, VALUE options)
 
   if (backend->instance != nullptr) {
     CB_LOG_TRACE("Trying to open the same backend twice: {}, instance={}",
-                 rb_sprintf("%+" PRIsVALUE ", connection_string=%+" PRIsVALUE, self, connstr),
+                 cb_sprintf("%+" PRIsVALUE ", connection_string=%+" PRIsVALUE, self, connstr),
                  static_cast<const void*>(backend->instance.get()));
     return Qnil;
   }
 
-  Check_Type(connstr, T_STRING);
+  cb_check_type(connstr, T_STRING);
 
   try {
     auto connection_string = cb_string_new(connstr);
@@ -535,10 +546,8 @@ cb_Backend_open(VALUE self, VALUE connstr, VALUE credentials, VALUE options)
     backend->instance = std::make_unique<couchbase::cluster>(std::move(cluster));
     instances.add(backend->instance.get());
   } 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;
 }
@@ -558,7 +567,7 @@ cb_Backend_open_bucket(VALUE self, VALUE bucket, VALUE wait_until_ready)
 {
   const auto& cluster = cb_backend_to_core_api_cluster(self);
 
-  Check_Type(bucket, T_STRING);
+  cb_check_type(bucket, T_STRING);
   bool wait = RTEST(wait_until_ready);
 
   try {
@@ -579,10 +588,8 @@ cb_Backend_open_bucket(VALUE self, VALUE bucket, VALUE wait_until_ready)
       });
     }
   } 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;
 }
@@ -610,10 +617,8 @@ cb_Backend_update_credentials(VALUE self, VALUE credentials)
       cb_throw_error(err, "failed to update authenticator");
     }
   } 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 update authenticator {}: {}", __func__, se.what()), false));
-  } catch (const ruby_exception& e) {
-    rb_exc_raise(e.exception_object());
   }
 
   return Qnil;
@@ -626,12 +631,13 @@ init_backend(VALUE mCouchbase)
 {
   VALUE cBackend = rb_define_class_under(mCouchbase, "Backend", rb_cObject);
   rb_define_alloc_func(cBackend, cb_Backend_allocate);
-  rb_define_method(cBackend, "open", cb_Backend_open, 3);
-  rb_define_method(cBackend, "open_bucket", cb_Backend_open_bucket, 2);
+  rb_define_method(cBackend, "open", cb_method<cb_Backend_open>::invoke, 3);
+  rb_define_method(cBackend, "open_bucket", cb_method<cb_Backend_open_bucket>::invoke, 2);
   rb_define_method(cBackend, "close", cb_Backend_close, 0);
-  rb_define_method(cBackend, "update_credentials", cb_Backend_update_credentials, 1);
+  rb_define_method(
+    cBackend, "update_credentials", cb_method<cb_Backend_update_credentials>::invoke, 1);
 
-  rb_define_singleton_method(cBackend, "notify_fork", cb_Backend_notify_fork, 1);
+  rb_define_singleton_method(cBackend, "notify_fork", cb_method<cb_Backend_notify_fork>::invoke, 1);
   return cBackend;
 }
 
@@ -642,7 +648,7 @@ cb_backend_to_public_api_cluster(VALUE self) -> couchbase::cluster
   TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
 
   if (backend->instance == nullptr) {
-    rb_raise(exc_cluster_closed(), "Cluster has been closed already");
+    throw ruby_exception(exc_cluster_closed(), "Cluster has been closed already");
   }
 
   return *backend->instance;

data/ext/rcb_backend.hxx

@@ -33,6 +33,8 @@ class cluster;
 
 namespace couchbase::ruby
 {
+// Both throw ruby_exception with Error::ClusterClosed once the backend is closed, so they may be
+// called only from a method body registered through cb_method.
 auto
 cb_backend_to_public_api_cluster(VALUE self) -> couchbase::cluster;