couchbase 3.5.4 → 3.5.6

data/ext/couchbase/couchbase/fmt/search_scan_consistency.hxx

@@ -19,8 +19,6 @@
 
 #include <couchbase/search_scan_consistency.hxx>
 
-#include <fmt/core.h>
-
 /**
  * Helper for fmtlib to format @ref couchbase::search_scan_consistency objects.
  *

data/ext/couchbase/couchbase/fmt/tls_verify_mode.hxx

@@ -19,8 +19,6 @@
 
 #include <couchbase/tls_verify_mode.hxx>
 
-#include <fmt/core.h>
-
 /**
  * Helper for fmtlib to format @ref couchbase::tls_verify_mode objects.
  *

data/ext/couchbase/couchbase/fmt/transaction_keyspace.hxx

@@ -18,8 +18,6 @@
 
 #include <couchbase/transactions/transaction_keyspace.hxx>
 
-#include <fmt/core.h>
-
 template<>
 struct fmt::formatter<couchbase::transactions::transaction_keyspace> {
 public:

data/ext/couchbase/couchbase/metrics/otel_meter.hxx

@@ -20,6 +20,7 @@
 #include "opentelemetry/sdk/metrics/meter.h"
 #include <couchbase/metrics/meter.hxx>
 
+#include <algorithm>
 #include <iostream>
 #include <thread>
 #include <utility>
@@ -37,44 +38,39 @@ namespace couchbase::metrics
 class otel_sync_histogram
 {
 public:
-  otel_sync_histogram(nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter)
+  otel_sync_histogram(nostd::shared_ptr<metrics_api::Histogram<std::uint64_t>> histogram_counter)
     : histogram_counter_(histogram_counter)
   {
   }
-  void record(uint64_t value,
+
+  void record(std::uint64_t value,
               const opentelemetry::common::KeyValueIterable& tags,
               opentelemetry::context::Context& ctx)
   {
-    // overflow
-    if (value > LONG_MAX) {
-      value = LONG_MAX;
-    }
-    long lvalue = static_cast<long>(value);
-    histogram_counter_->Record(lvalue, tags, ctx);
+    histogram_counter_->Record(value, tags, ctx);
   }
 
 private:
-  nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter_;
+  nostd::shared_ptr<metrics_api::Histogram<std::uint64_t>> histogram_counter_;
   std::mutex mutex_;
 };
 
 class otel_value_recorder : public couchbase::metrics::value_recorder
 {
 public:
-  explicit otel_value_recorder(nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter,
-                               const std::map<std::string, std::string>& tags)
+  explicit otel_value_recorder(
+    nostd::shared_ptr<metrics_api::Histogram<std::uint64_t>> histogram_counter,
+    const std::map<std::string, std::string>& tags)
     : histogram_counter_(histogram_counter)
     , tags_(tags)
   {
   }
   void record_value(std::int64_t value) override
   {
-    if (value > LONG_MAX) {
-      value = LONG_MAX;
-    }
-    long lvalue = static_cast<long>(value);
+    value = std::max<int64_t>(value, 0);
+    auto uvalue = static_cast<std::uint64_t>(value);
     histogram_counter_->Record(
-      value, opentelemetry::common::KeyValueIterableView<decltype(tags_)>{ tags_ }, context_);
+      uvalue, opentelemetry::common::KeyValueIterableView<decltype(tags_)>{ tags_ }, context_);
   }
 
   const std::map<std::string, std::string> tags()
@@ -82,13 +78,13 @@ public:
     return tags_;
   }
 
-  nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter()
+  nostd::shared_ptr<metrics_api::Histogram<std::uint64_t>> histogram_counter()
   {
     return histogram_counter_;
   }
 
 private:
-  nostd::shared_ptr<metrics_api::Histogram<long>> histogram_counter_;
+  nostd::shared_ptr<metrics_api::Histogram<std::uint64_t>> histogram_counter_;
   const std::map<std::string, std::string> tags_;
   opentelemetry::context::Context context_{};
   std::mutex mutex_;
@@ -115,8 +111,8 @@ public:
       // api doesn't seem to allow this.
       return recorders_
         .insert({ name,
-                  std::make_shared<otel_value_recorder>(meter_->CreateLongHistogram(name, "", "us"),
-                                                        tags) })
+                  std::make_shared<otel_value_recorder>(
+                    meter_->CreateUInt64Histogram(name, "", "us"), tags) })
         ->second;
     }
     // so it is already, lets see if we already have one with those tags, or need

data/ext/couchbase.cxx

@@ -41,6 +41,7 @@ __declspec(dllexport)
 void
 Init_libcouchbase(void)
 {
+  couchbase::ruby::install_terminate_handler();
   couchbase::ruby::init_logger();
 
   VALUE mCouchbase = rb_define_module("Couchbase");

data/ext/extconf.rb

@@ -104,6 +104,7 @@ if ENV["CB_STATIC"] || ENV["CB_STATIC_BORINGSSL"]
 elsif ENV["CB_STATIC_OPENSSL"]
   cmake_flags << "-DCOUCHBASE_CXX_CLIENT_STATIC_OPENSSL=ON"
 end
+cmake_flags << "-DCOUCHBASE_CXX_CLIENT_WRAPPER_UNIFIED_ID=ruby/#{Couchbase::VERSION[:sdk]}"
 
 unless cmake_flags.grep(/BORINGSSL/)
   case RbConfig::CONFIG["target_os"]
@@ -153,6 +154,16 @@ build_dir = ENV['CB_EXT_BUILD_DIR'] ||
             File.join(Dir.tmpdir, "cb-#{build_type}-#{RUBY_VERSION}-#{RUBY_PATCHLEVEL}-#{RUBY_PLATFORM}-#{SDK_VERSION}")
 FileUtils.rm_rf(build_dir, verbose: true) unless ENV['CB_PRESERVE_BUILD_DIR']
 FileUtils.mkdir_p(build_dir, verbose: true)
+if ENV["CB_CREATE_BUILD_DIR_LINK"]
+  links = [
+    File.expand_path(File.join(project_path, "..", "build")),
+    File.expand_path(File.join(project_path, "build"))
+  ]
+  links.each do |link|
+    next if link == build_dir
+    FileUtils.ln_sf(build_dir, link, verbose: true)
+  end
+end
 Dir.chdir(build_dir) do
   puts "-- build #{build_type} extension #{SDK_VERSION} for ruby #{RUBY_VERSION}-#{RUBY_PATCHLEVEL}-#{RUBY_PLATFORM}"
   sys(cmake, *cmake_flags, "-B#{build_dir}", "-S#{project_path}")

data/ext/rcb_analytics.cxx

@@ -36,7 +36,7 @@
 #include <core/operations/management/analytics_link_get_all.hxx>
 #include <core/operations/management/analytics_link_replace.hxx>
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <future>
 #include <memory>
@@ -911,17 +911,17 @@ cb_Backend_analytics_link_get_all(VALUE self, VALUE options)
         cb_throw_error(
           resp.ctx,
           fmt::format(R"(unable to retrieve links type={}, dataverse="{}",  name="{}")",
-                      req.link_type,
-                      req.link_name,
-                      req.dataverse_name));
+                      req.link_type.value_or("-"),
+                      req.link_name.value_or("-"),
+                      req.dataverse_name.value_or("-")));
       } else {
         const auto& first_error = resp.errors.front();
         cb_throw_error(
           resp.ctx,
           fmt::format(R"(unable to retrieve links type={}, dataverse="{}",  name="{}" ({}: {}))",
-                      req.link_type,
-                      req.link_name,
-                      req.dataverse_name,
+                      req.link_type.value_or("-"),
+                      req.link_name.value_or("-"),
+                      req.dataverse_name.value_or("-"),
                       first_error.code,
                       first_error.message));
       }

data/ext/rcb_backend.cxx

@@ -17,19 +17,23 @@
 
 #include <couchbase/cluster.hxx>
 
+#include <couchbase/fork_event.hxx>
+#include <couchbase/ip_protocol.hxx>
+
 #include <core/cluster.hxx>
 #include <core/logger/logger.hxx>
 #include <core/utils/connection_string.hxx>
 
 #include <asio/io_context.hpp>
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <future>
+#include <list>
 #include <memory>
+#include <mutex>
 
 #include <ruby.h>
 
-#include "couchbase/ip_protocol.hxx"
 #include "rcb_backend.hxx"
 #include "rcb_exceptions.hxx"
 #include "rcb_logger.hxx"
@@ -44,10 +48,79 @@ struct cb_backend_data {
   std::unique_ptr<cluster> instance{ nullptr };
 };
 
+class instance_registry
+{
+public:
+  void add(cluster* instance)
+  {
+    std::scoped_lock lock(instances_mutex_);
+    known_instances_.push_back(instance);
+  }
+
+  void remove(cluster* instance)
+  {
+    std::scoped_lock lock(instances_mutex_);
+    known_instances_.remove(instance);
+  }
+
+  void notify_fork(couchbase::fork_event event)
+  {
+    if (event != couchbase::fork_event::prepare) {
+      init_logger();
+    }
+
+    {
+      std::scoped_lock lock(instances_mutex_);
+      for (auto* instance : known_instances_) {
+        instance->notify_fork(event);
+      }
+    }
+
+    if (event == couchbase::fork_event::prepare) {
+      flush_logger();
+      couchbase::core::logger::shutdown();
+    }
+  }
+
+private:
+  std::mutex instances_mutex_;
+  std::list<cluster*> known_instances_;
+};
+
+instance_registry instances;
+
+VALUE
+cb_Backend_notify_fork(VALUE self, VALUE event)
+{
+  static const auto id_prepare{ rb_intern("prepare") };
+  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());
+  }
+
+  return Qnil;
+}
+
 void
 cb_backend_close(cb_backend_data* backend)
 {
   if (auto instance = std::move(backend->instance); instance) {
+    instances.remove(instance.get());
     auto promise = std::make_shared<std::promise<void>>();
     auto f = promise->get_future();
     instance->close([promise = std::move(promise)]() mutable {
@@ -208,6 +281,11 @@ initialize_cluster_options(const core::utils::connection_string& connstr,
     cluster_options.network().preferred_network(param.value());
   }
 
+  static const auto server_group = rb_id2sym(rb_intern("preferred_server_group"));
+  if (auto group = options::get_string(options, server_group); group) {
+    cluster_options.network().preferred_server_group(group.value());
+  }
+
   static const auto sym_use_ip_protocol = rb_id2sym(rb_intern("use_ip_protocol"));
   if (auto proto = options::get_symbol(options, sym_use_ip_protocol); proto) {
     static const auto sym_any = rb_id2sym(rb_intern("any"));
@@ -441,6 +519,7 @@ cb_Backend_open(VALUE self, VALUE connstr, VALUE credentials, VALUE options)
         error, fmt::format("failed to connect to the Couchbase Server \"{}\"", connection_string));
     }
     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(
       se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
@@ -504,6 +583,8 @@ init_backend(VALUE mCouchbase)
   rb_define_method(cBackend, "open", cb_Backend_open, 3);
   rb_define_method(cBackend, "open_bucket", cb_Backend_open_bucket, 2);
   rb_define_method(cBackend, "close", cb_Backend_close, 0);
+
+  rb_define_singleton_method(cBackend, "notify_fork", cb_Backend_notify_fork, 1);
   return cBackend;
 }
 

data/ext/rcb_buckets.cxx

@@ -24,7 +24,7 @@
 #include <core/operations/management/bucket_get_all.hxx>
 #include <core/operations/management/bucket_update.hxx>
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <future>
 #include <memory>

data/ext/rcb_collections.cxx

@@ -23,7 +23,7 @@
 #include <core/operations/management/scope_drop.hxx>
 #include <core/operations/management/scope_get_all.hxx>
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <future>
 #include <memory>

data/ext/rcb_crud.cxx

@@ -128,7 +128,7 @@ cb_Backend_document_get_any_replica(VALUE self,
                                     VALUE id,
                                     VALUE options)
 {
-  auto cluster = cb_backend_to_public_api_cluster(self);
+  auto cluster = cb_backend_to_core_api_cluster(self);
 
   Check_Type(bucket, T_STRING);
   Check_Type(scope, T_STRING);
@@ -136,23 +136,32 @@ cb_Backend_document_get_any_replica(VALUE self,
   Check_Type(id, T_STRING);
 
   try {
-    couchbase::get_any_replica_options opts;
-    set_timeout(opts, options);
+    core::document_id doc_id{
+      cb_string_new(bucket),
+      cb_string_new(scope),
+      cb_string_new(collection),
+      cb_string_new(id),
+    };
 
-    auto f = cluster.bucket(cb_string_new(bucket))
-               .scope(cb_string_new(scope))
-               .collection(cb_string_new(collection))
-               .get_any_replica(cb_string_new(id), opts);
-    auto [ctx, resp] = cb_wait_for_future(f);
-    if (ctx.ec()) {
-      cb_throw_error(ctx, "unable to get replica of the document");
+    core::operations::get_any_replica_request req{ doc_id };
+    cb_extract_timeout(req, options);
+    cb_extract_read_preference(req, options);
+
+    std::promise<core::operations::get_any_replica_response> promise;
+    auto f = promise.get_future();
+    cluster.execute(req, [promise = std::move(promise)](auto&& resp) mutable {
+      promise.set_value(std::forward<decltype(resp)>(resp));
+    });
+    auto resp = cb_wait_for_future(f);
+    if (resp.ctx.ec()) {
+      cb_throw_error(resp.ctx, "unable to get replica of the document");
     }
 
-    auto value = resp.content_as<passthrough_transcoder>();
     VALUE res = rb_hash_new();
-    rb_hash_aset(res, rb_id2sym(rb_intern("content")), cb_str_new(value.data));
-    rb_hash_aset(res, rb_id2sym(rb_intern("cas")), cb_cas_to_num(resp.cas()));
-    rb_hash_aset(res, rb_id2sym(rb_intern("flags")), UINT2NUM(value.flags));
+    rb_hash_aset(res, rb_id2sym(rb_intern("content")), cb_str_new(resp.value));
+    rb_hash_aset(res, rb_id2sym(rb_intern("cas")), cb_cas_to_num(resp.cas));
+    rb_hash_aset(res, rb_id2sym(rb_intern("flags")), UINT2NUM(resp.flags));
+    rb_hash_aset(res, rb_id2sym(rb_intern("replica")), resp.replica ? Qtrue : Qfalse);
     return res;
   } catch (const std::system_error& se) {
     rb_exc_raise(cb_map_error_code(
@@ -171,7 +180,7 @@ cb_Backend_document_get_all_replicas(VALUE self,
                                      VALUE id,
                                      VALUE options)
 {
-  auto cluster = cb_backend_to_public_api_cluster(self);
+  auto cluster = cb_backend_to_core_api_cluster(self);
 
   Check_Type(bucket, T_STRING);
   Check_Type(scope, T_STRING);
@@ -179,25 +188,35 @@ cb_Backend_document_get_all_replicas(VALUE self,
   Check_Type(id, T_STRING);
 
   try {
-    couchbase::get_all_replicas_options opts;
-    set_timeout(opts, options);
+    core::document_id doc_id{
+      cb_string_new(bucket),
+      cb_string_new(scope),
+      cb_string_new(collection),
+      cb_string_new(id),
+    };
 
-    auto f = cluster.bucket(cb_string_new(bucket))
-               .scope(cb_string_new(scope))
-               .collection(cb_string_new(collection))
-               .get_all_replicas(cb_string_new(id), opts);
-    auto [ctx, resp] = cb_wait_for_future(f);
-    if (ctx.ec()) {
-      cb_throw_error(ctx, "unable to get all replicas for the document");
+    core::operations::get_all_replicas_request req{ doc_id };
+    cb_extract_timeout(req, options);
+    cb_extract_read_preference(req, options);
+
+    std::promise<core::operations::get_all_replicas_response> promise;
+    auto f = promise.get_future();
+    cluster.execute(req, [promise = std::move(promise)](auto&& resp) mutable {
+      promise.set_value(std::forward<decltype(resp)>(resp));
+    });
+    auto resp = cb_wait_for_future(f);
+    if (resp.ctx.ec()) {
+      cb_throw_error(resp.ctx, "unable to get all replicas for the document");
     }
 
-    VALUE res = rb_ary_new_capa(static_cast<long>(resp.size()));
-    for (const auto& entry : resp) {
+    VALUE res = rb_ary_new_capa(static_cast<long>(resp.entries.size()));
+
+    for (const auto& entry : resp.entries) {
       VALUE response = rb_hash_new();
-      auto value = entry.content_as<passthrough_transcoder>();
-      rb_hash_aset(response, rb_id2sym(rb_intern("content")), cb_str_new(value.data));
-      rb_hash_aset(response, rb_id2sym(rb_intern("cas")), cb_cas_to_num(entry.cas()));
-      rb_hash_aset(response, rb_id2sym(rb_intern("flags")), UINT2NUM(value.flags));
+      rb_hash_aset(response, rb_id2sym(rb_intern("content")), cb_str_new(entry.value));
+      rb_hash_aset(response, rb_id2sym(rb_intern("cas")), cb_cas_to_num(entry.cas));
+      rb_hash_aset(response, rb_id2sym(rb_intern("flags")), UINT2NUM(entry.flags));
+      rb_hash_aset(response, rb_id2sym(rb_intern("replica")), entry.replica ? Qtrue : Qfalse);
       rb_ary_push(res, response);
     }
     return res;
@@ -1107,6 +1126,7 @@ cb_Backend_document_lookup_in_any_replica(VALUE self,
 
     core::operations::lookup_in_any_replica_request req{ doc_id };
     cb_extract_timeout(req, options);
+    cb_extract_read_preference(req, options);
 
     static VALUE xattr_property = rb_id2sym(rb_intern("xattr"));
     static VALUE path_property = rb_id2sym(rb_intern("path"));
@@ -1234,6 +1254,7 @@ cb_Backend_document_lookup_in_all_replicas(VALUE self,
 
     core::operations::lookup_in_all_replicas_request req{ doc_id };
     cb_extract_timeout(req, options);
+    cb_extract_read_preference(req, options);
 
     static VALUE xattr_property = rb_id2sym(rb_intern("xattr"));
     static VALUE path_property = rb_id2sym(rb_intern("path"));

data/ext/rcb_diagnostics.cxx

@@ -17,7 +17,7 @@
 
 #include <core/cluster.hxx>
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <future>
 

data/ext/rcb_exceptions.cxx

@@ -17,7 +17,6 @@
 
 #include <couchbase/error.hxx>
 #include <couchbase/error_codes.hxx>
-#include <couchbase/fmt/retry_reason.hxx>
 
 #include <core/error_context/analytics.hxx>
 #include <core/error_context/http.hxx>
@@ -27,7 +26,9 @@
 #include <core/error_context/view.hxx>
 #include <core/fmt/key_value_status_code.hxx>
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
+
+#include <couchbase/fmt/retry_reason.hxx>
 
 #include "rcb_exceptions.hxx"
 #include "rcb_utils.hxx"

data/ext/rcb_extras.cxx

@@ -26,8 +26,8 @@
 #include <core/utils/unsigned_leb128.hxx>
 #include <core/utils/url_codec.hxx>
 
-#include <fmt/core.h>
 #include <snappy.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <future>
 #include <string>

data/ext/rcb_logger.cxx

@@ -268,13 +268,18 @@ cb_Backend_install_logger_shim(VALUE self, VALUE logger, VALUE log_level)
 } // namespace
 
 void
-init_logger()
+install_terminate_handler()
 {
   if (auto env_val =
         spdlog::details::os::getenv("COUCHBASE_BACKEND_DONT_INSTALL_TERMINATE_HANDLER");
       env_val.empty()) {
     core::platform::install_backtrace_terminate_handler();
   }
+}
+
+void
+init_logger()
+{
   if (auto env_val = spdlog::details::os::getenv("COUCHBASE_BACKEND_DONT_USE_BUILTIN_LOGGER");
       env_val.empty()) {
     auto default_log_level = core::logger::level::info;

data/ext/rcb_logger.hxx

@@ -22,6 +22,9 @@
 
 namespace couchbase::ruby
 {
+void
+install_terminate_handler();
+
 void
 init_logger();
 

data/ext/rcb_range_scan.cxx

@@ -24,7 +24,7 @@
 #include <core/scan_result.hxx>
 #include <couchbase/error_codes.hxx>
 
-#include <fmt/core.h>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <future>
 
@@ -245,13 +245,11 @@ cb_Backend_document_scan_create(VALUE self,
     std::promise<tl::expected<couchbase::core::topology::configuration, std::error_code>> promise;
     auto f = promise.get_future();
     cluster.with_bucket_configuration(
-      bucket_name,
-      [promise = std::move(promise)](
-        std::error_code ec, const couchbase::core::topology::configuration& config) mutable {
+      bucket_name, [promise = std::move(promise)](std::error_code ec, const auto& config) mutable {
         if (ec) {
           return promise.set_value(tl::unexpected(ec));
         }
-        promise.set_value(config);
+        promise.set_value(*config);
       });
     auto config = cb_wait_for_future(f);
     if (!config.has_value()) {

data/ext/rcb_search.cxx

@@ -30,8 +30,8 @@
 #include <core/operations/management/search_index_get_stats.hxx>
 #include <core/operations/management/search_index_upsert.hxx>
 
-#include <fmt/core.h>
 #include <gsl/narrow>
+#include <spdlog/fmt/bundled/core.h>
 
 #include <future>
 #include <memory>

data/ext/rcb_users.cxx

@@ -28,8 +28,8 @@
 #include <core/operations/management/user_get_all.hxx>
 #include <core/operations/management/user_upsert.hxx>
 
-#include <fmt/core.h>
-#include <fmt/ranges.h>
+#include <spdlog/fmt/bundled/core.h>
+#include <spdlog/fmt/bundled/ranges.h>
 
 #include <future>
 #include <memory>

data/ext/rcb_utils.hxx

@@ -21,6 +21,7 @@
 #include <couchbase/cas.hxx>
 #include <couchbase/durability_level.hxx>
 #include <couchbase/persist_to.hxx>
+#include <couchbase/read_preference.hxx>
 #include <couchbase/replicate_to.hxx>
 #include <couchbase/store_semantics.hxx>
 
@@ -128,6 +129,37 @@ cb_extract_timeout(Request& req, VALUE options)
   }
 }
 
+template<typename Request>
+inline void
+cb_extract_read_preference(Request& req, VALUE options)
+{
+  static VALUE property_name = rb_id2sym(rb_intern("read_preference"));
+  if (!NIL_P(options)) {
+    if (TYPE(options) != T_HASH) {
+      throw ruby_exception(rb_eArgError,
+                           rb_sprintf("expected options to be Hash, given %+" PRIsVALUE, options));
+    }
+
+    VALUE val = rb_hash_aref(options, property_name);
+    if (NIL_P(val)) {
+      return;
+    }
+    if (TYPE(val) != T_SYMBOL) {
+      throw ruby_exception(
+        rb_eArgError, rb_sprintf("read_preference must be a Symbol, but given %+" PRIsVALUE, val));
+    }
+
+    if (ID mode = rb_sym2id(val); mode == rb_intern("no_preference")) {
+      req.read_preference = couchbase::read_preference::no_preference;
+    } else if (mode == rb_intern("selected_server_group")) {
+      req.read_preference = couchbase::read_preference::selected_server_group;
+    } else {
+      throw ruby_exception(rb_eArgError,
+                           rb_sprintf("unexpected read_preference, given %+" PRIsVALUE, val));
+    }
+  }
+}
+
 template<typename Field>
 inline void
 cb_extract_duration(Field& field, VALUE options, const char* name)

data/lib/couchbase/bucket.rb

@@ -134,13 +134,5 @@ module Couchbase
         end
       end
     end
-
-    # @api private
-    # TODO: deprecate in 3.1
-    PingOptions = ::Couchbase::Options::Ping
-
-    # @api private
-    # TODO: deprecate in 3.1
-    ViewOptions = ::Couchbase::Options::View
   end
 end