couchbase 3.7.0 → 3.8.0

data/ext/rcb_utils.hxx

@@ -20,6 +20,7 @@
 
 #include <couchbase/cas.hxx>
 #include <couchbase/durability_level.hxx>
+#include <couchbase/expiry.hxx>
 #include <couchbase/persist_to.hxx>
 #include <couchbase/read_preference.hxx>
 #include <couchbase/replicate_to.hxx>
@@ -106,6 +107,9 @@ get_uint16_t(VALUE options, VALUE name);
 std::optional<VALUE>
 get_symbol(VALUE options, VALUE name);
 
+std::optional<VALUE>
+get_hash(VALUE options, VALUE name);
+
 std::optional<std::string>
 get_string(VALUE options, VALUE name);
 } // namespace options
@@ -129,6 +133,43 @@ cb_extract_timeout(Request& req, VALUE options)
   }
 }
 
+template<typename Request>
+inline void
+cb_extract_durability_level(Request& req, VALUE options)
+{
+  if (NIL_P(options)) {
+    return;
+  }
+
+  if (TYPE(options) != T_HASH) {
+    throw ruby_exception(rb_eArgError,
+                         rb_sprintf("expected options to be Hash, given %+" PRIsVALUE, options));
+  }
+
+  static VALUE property_name = rb_id2sym(rb_intern("durability_level"));
+
+  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("durability_level must be a Symbol, but given %+" PRIsVALUE, val));
+  }
+  if (ID level = rb_sym2id(val); level == rb_intern("none")) {
+    req.durability_level = couchbase::durability_level::none;
+  } else if (level == rb_intern("majority")) {
+    req.durability_level = couchbase::durability_level::majority;
+  } else if (level == rb_intern("majority_and_persist_to_active")) {
+    req.durability_level = couchbase::durability_level::majority_and_persist_to_active;
+  } else if (level == rb_intern("persist_to_majority")) {
+    req.durability_level = couchbase::durability_level::persist_to_majority;
+  } else {
+    throw ruby_exception(rb_eArgError,
+                         rb_sprintf("unexpected durability_level, given %+" PRIsVALUE, val));
+  }
+}
+
 template<typename Request>
 inline void
 cb_extract_read_preference(Request& req, VALUE options)
@@ -179,6 +220,26 @@ cb_extract_duration(Field& field, VALUE options, const char* name)
   }
 }
 
+void
+cb_extract_content(std::vector<std::byte>& field, VALUE content);
+
+template<typename Request>
+inline void
+cb_extract_content(Request& req, VALUE options)
+{
+  cb_extract_content(req.value, options);
+}
+
+void
+cb_extract_flags(std::uint32_t& field, VALUE flags);
+
+template<typename Request>
+inline void
+cb_extract_flags(Request& req, VALUE options)
+{
+  cb_extract_flags(req.flags, options);
+}
+
 void
 cb_extract_timeout(std::chrono::milliseconds& field, VALUE options);
 
@@ -263,6 +324,41 @@ cb_extract_option_array(VALUE& val, VALUE options, const char* name);
 void
 cb_extract_cas(couchbase::cas& field, VALUE cas);
 
+template<typename Request>
+inline void
+cb_extract_cas(Request& req, VALUE options)
+{
+  if (NIL_P(options) || TYPE(options) != T_HASH) {
+    return;
+  }
+  static VALUE property_name = rb_id2sym(rb_intern("cas"));
+  VALUE cas_value = rb_hash_aref(options, property_name);
+  if (NIL_P(cas_value)) {
+    return;
+  }
+  cb_extract_cas(req.cas, cas_value);
+}
+
+void
+cb_extract_expiry(std::uint32_t& field, VALUE options);
+
+void
+cb_extract_expiry(std::optional<std::uint32_t>& field, VALUE options);
+
+template<typename Request>
+inline void
+cb_extract_expiry(Request& req, VALUE options)
+{
+  cb_extract_expiry(req.expiry, options);
+}
+
+template<typename Request>
+inline void
+cb_extract_preserve_expiry(Request& req, VALUE options)
+{
+  cb_extract_option_bool(req.preserve_expiry, options, "preserve_expiry");
+}
+
 VALUE
 cb_cas_to_num(const couchbase::cas& cas);
 
@@ -272,6 +368,24 @@ cb_num_to_cas(VALUE num);
 VALUE
 to_cas_value(couchbase::cas cas);
 
+template<typename Response>
+inline VALUE
+cb_create_mutation_result(Response resp)
+{
+  VALUE res = rb_hash_new();
+  rb_hash_aset(res, rb_id2sym(rb_intern("cas")), to_cas_value(resp.cas));
+
+  VALUE token = rb_hash_new();
+  rb_hash_aset(token, rb_id2sym(rb_intern("partition_uuid")), ULL2NUM(resp.token.partition_uuid()));
+  rb_hash_aset(
+    token, rb_id2sym(rb_intern("sequence_number")), ULL2NUM(resp.token.sequence_number()));
+  rb_hash_aset(token, rb_id2sym(rb_intern("partition_id")), UINT2NUM(resp.token.partition_id()));
+  rb_hash_aset(token, rb_id2sym(rb_intern("bucket_name")), cb_str_new(resp.token.bucket_name()));
+  rb_hash_aset(res, rb_id2sym(rb_intern("mutation_token")), token);
+
+  return res;
+}
+
 template<typename Response>
 inline VALUE
 to_mutation_result_value(Response resp)
@@ -361,66 +475,6 @@ set_expiry(CommandOptions& opts, VALUE options)
   }
 }
 
-template<typename CommandOptions>
-inline void
-set_access_deleted(CommandOptions& opts, VALUE options)
-{
-  static VALUE property_name = rb_id2sym(rb_intern("access_deleted"));
-  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;
-    }
-    switch (TYPE(val)) {
-      case T_TRUE:
-        opts.access_deleted(true);
-        break;
-      case T_FALSE:
-        opts.access_deleted(false);
-        break;
-
-      default:
-        throw ruby_exception(
-          rb_eArgError,
-          rb_sprintf("access_deleted must be an Boolean, but given %+" PRIsVALUE, val));
-    }
-  }
-}
-
-template<typename CommandOptions>
-inline void
-set_create_as_deleted(CommandOptions& opts, VALUE options)
-{
-  static VALUE property_name = rb_id2sym(rb_intern("create_as_deleted"));
-  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;
-    }
-    switch (TYPE(val)) {
-      case T_TRUE:
-        opts.create_as_deleted(true);
-        break;
-      case T_FALSE:
-        opts.create_as_deleted(false);
-        break;
-
-      default:
-        throw ruby_exception(
-          rb_eArgError,
-          rb_sprintf("create_as_deleted must be an Boolean, but given %+" PRIsVALUE, val));
-    }
-  }
-}
-
 template<typename CommandOptions>
 inline void
 set_preserve_expiry(CommandOptions& opts, VALUE options)
@@ -450,88 +504,6 @@ set_preserve_expiry(CommandOptions& opts, VALUE options)
   }
 }
 
-template<typename CommandOptions>
-inline void
-set_cas(CommandOptions& opts, VALUE options)
-{
-  static VALUE property_name = rb_id2sym(rb_intern("cas"));
-  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;
-    }
-    switch (TYPE(val)) {
-      case T_FIXNUM:
-      case T_BIGNUM:
-        opts.cas(couchbase::cas{ static_cast<std::uint64_t>(NUM2ULL(val)) });
-        break;
-
-      default:
-        throw ruby_exception(rb_eArgError,
-                             rb_sprintf("cas must be an Integer, but given %+" PRIsVALUE, val));
-    }
-  }
-}
-
-template<typename CommandOptions>
-inline void
-set_delta(CommandOptions& opts, VALUE options)
-{
-  static VALUE property_name = rb_id2sym(rb_intern("delta"));
-  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;
-    }
-    switch (TYPE(val)) {
-      case T_FIXNUM:
-      case T_BIGNUM:
-        opts.delta(NUM2ULL(val));
-        break;
-
-      default:
-        throw ruby_exception(rb_eArgError,
-                             rb_sprintf("delta must be an Integer, but given %+" PRIsVALUE, val));
-    }
-  }
-}
-
-template<typename CommandOptions>
-inline void
-set_initial_value(CommandOptions& opts, VALUE options)
-{
-  static VALUE property_name = rb_id2sym(rb_intern("initial_value"));
-  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;
-    }
-    switch (TYPE(val)) {
-      case T_FIXNUM:
-      case T_BIGNUM:
-        opts.initial(NUM2ULL(val));
-        break;
-
-      default:
-        throw ruby_exception(
-          rb_eArgError,
-          rb_sprintf("initial_value must be an Integer, but given %+" PRIsVALUE, val));
-    }
-  }
-}
-
 std::optional<couchbase::durability_level>
 extract_durability_level(VALUE options);
 
@@ -558,39 +530,40 @@ set_durability(CommandOptions& opts, VALUE options)
   }
 }
 
-template<typename CommandOptions>
+template<typename Request>
 inline void
-set_store_semantics(CommandOptions& opts, VALUE options)
+cb_extract_store_semantics(Request& req, VALUE options)
 {
   static VALUE property_name = rb_id2sym(rb_intern("store_semantics"));
-  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("store_semantics must be a Symbol, but given %+" PRIsVALUE, val));
-    }
+  if (NIL_P(options)) {
+    return;
+  }
+  if (TYPE(options) != T_HASH) {
+    throw ruby_exception(rb_eArgError,
+                         rb_sprintf("expected options to be Hash, given %+" PRIsVALUE, options));
+  }
 
-    if (ID mode = rb_sym2id(val); mode == rb_intern("replace")) {
-      opts.store_semantics(store_semantics::replace);
-    } else if (mode == rb_intern("insert")) {
-      opts.store_semantics(store_semantics::insert);
-    } else if (mode == rb_intern("upsert")) {
-      opts.store_semantics(store_semantics::upsert);
-    } else {
-      throw ruby_exception(rb_eArgError,
-                           rb_sprintf("unexpected store_semantics, given %+" PRIsVALUE, val));
-    }
+  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("store_semantics must be a Symbol, but given %+" PRIsVALUE, val));
   }
-}
 
+  if (ID mode = rb_sym2id(val); mode == rb_intern("replace")) {
+    req.store_semantics = couchbase::store_semantics::replace;
+  } else if (mode == rb_intern("insert")) {
+    req.store_semantics = couchbase::store_semantics::insert;
+  } else if (mode == rb_intern("upsert")) {
+    req.store_semantics = couchbase::store_semantics::upsert;
+  } else {
+    throw ruby_exception(rb_eArgError,
+                         rb_sprintf("unexpected store_semantics, given %+" PRIsVALUE, val));
+  }
+}
 } // namespace couchbase::ruby
 
 #endif

data/ext/rcb_views.cxx

@@ -15,6 +15,7 @@
  *   limitations under the License.
  */
 
+#define COUCHBASE_CXX_CLIENT_IGNORE_CORE_DEPRECATIONS
 #include <core/cluster.hxx>
 #include <core/design_document_namespace_fmt.hxx>
 #include <core/operations/document_view.hxx>
@@ -22,12 +23,14 @@
 #include <core/operations/management/view_index_get.hxx>
 #include <core/operations/management/view_index_get_all.hxx>
 #include <core/operations/management/view_index_upsert.hxx>
+#undef COUCHBASE_CXX_CLIENT_IGNORE_CORE_DEPRECATIONS
 
 #include <future>
 
 #include <ruby.h>
 
 #include "rcb_backend.hxx"
+#include "rcb_observability.hxx"
 #include "rcb_utils.hxx"
 
 namespace couchbase::ruby
@@ -35,7 +38,11 @@ namespace couchbase::ruby
 namespace
 {
 VALUE
-cb_Backend_view_index_get_all(VALUE self, VALUE bucket_name, VALUE name_space, VALUE timeout)
+cb_Backend_view_index_get_all(VALUE self,
+                              VALUE bucket_name,
+                              VALUE name_space,
+                              VALUE timeout,
+                              VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -57,12 +64,14 @@ cb_Backend_view_index_get_all(VALUE self, VALUE bucket_name, VALUE name_space, V
     req.bucket_name = cb_string_new(bucket_name);
     req.ns = ns;
     cb_extract_timeout(req, timeout);
+    auto parent_span = cb_create_parent_span(req, self);
     std::promise<core::operations::management::view_index_get_all_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);
+    cb_add_core_spans(observability_handler, std::move(parent_span), resp.ctx.retry_attempts);
     if (resp.ctx.ec) {
       cb_throw_error(resp.ctx, "unable to get list of the design documents");
     }
@@ -110,7 +119,8 @@ cb_Backend_view_index_get(VALUE self,
                           VALUE bucket_name,
                           VALUE document_name,
                           VALUE name_space,
-                          VALUE timeout)
+                          VALUE timeout,
+                          VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -134,12 +144,14 @@ cb_Backend_view_index_get(VALUE self,
     req.document_name = cb_string_new(document_name);
     req.ns = ns;
     cb_extract_timeout(req, timeout);
+    auto parent_span = cb_create_parent_span(req, self);
     std::promise<core::operations::management::view_index_get_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);
+    cb_add_core_spans(observability_handler, std::move(parent_span), resp.ctx.retry_attempts);
     if (resp.ctx.ec) {
       cb_throw_error(resp.ctx,
                      fmt::format(R"(unable to get design document "{}" ({}) on bucket "{}")",
@@ -187,7 +199,8 @@ cb_Backend_view_index_drop(VALUE self,
                            VALUE bucket_name,
                            VALUE document_name,
                            VALUE name_space,
-                           VALUE timeout)
+                           VALUE timeout,
+                           VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -211,13 +224,16 @@ cb_Backend_view_index_drop(VALUE self,
     req.document_name = cb_string_new(document_name);
     req.ns = ns;
     cb_extract_timeout(req, timeout);
+    auto parent_span = cb_create_parent_span(req, self);
     std::promise<core::operations::management::view_index_drop_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));
     });
 
-    if (auto resp = cb_wait_for_future(f); resp.ctx.ec) {
+    auto resp = cb_wait_for_future(f);
+    cb_add_core_spans(observability_handler, std::move(parent_span), resp.ctx.retry_attempts);
+    if (resp.ctx.ec) {
       cb_throw_error(resp.ctx,
                      fmt::format(R"(unable to drop design document "{}" ({}) on bucket "{}")",
                                  req.document_name,
@@ -239,7 +255,8 @@ cb_Backend_view_index_upsert(VALUE self,
                              VALUE bucket_name,
                              VALUE document,
                              VALUE name_space,
-                             VALUE timeout)
+                             VALUE timeout,
+                             VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -287,13 +304,16 @@ cb_Backend_view_index_upsert(VALUE self,
     }
 
     cb_extract_timeout(req, timeout);
+    auto parent_span = cb_create_parent_span(req, self);
     std::promise<core::operations::management::view_index_upsert_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));
     });
 
-    if (auto resp = cb_wait_for_future(f); resp.ctx.ec) {
+    auto resp = cb_wait_for_future(f);
+    cb_add_core_spans(observability_handler, std::move(parent_span), resp.ctx.retry_attempts);
+    if (resp.ctx.ec) {
       cb_throw_error(resp.ctx,
                      fmt::format(R"(unable to store design document "{}" ({}) on bucket "{}")",
                                  req.document.name,
@@ -316,7 +336,8 @@ cb_Backend_document_view(VALUE self,
                          VALUE design_document_name,
                          VALUE view_name,
                          VALUE name_space,
-                         VALUE options)
+                         VALUE options,
+                         VALUE observability_handler)
 {
   auto cluster = cb_backend_to_core_api_cluster(self);
 
@@ -420,12 +441,15 @@ cb_Backend_document_view(VALUE self,
       }
     }
 
+    auto parent_span = cb_create_parent_span(req, self);
+
     std::promise<core::operations::document_view_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);
+    cb_add_core_spans(observability_handler, std::move(parent_span), resp.ctx.retry_attempts);
     if (resp.ctx.ec) {
       if (resp.error) {
         cb_throw_error(resp.ctx,
@@ -475,11 +499,11 @@ cb_Backend_document_view(VALUE self,
 void
 init_views(VALUE cBackend)
 {
-  rb_define_method(cBackend, "document_view", cb_Backend_document_view, 5);
+  rb_define_method(cBackend, "document_view", cb_Backend_document_view, 6);
 
-  rb_define_method(cBackend, "view_index_get_all", cb_Backend_view_index_get_all, 3);
-  rb_define_method(cBackend, "view_index_get", cb_Backend_view_index_get, 4);
-  rb_define_method(cBackend, "view_index_drop", cb_Backend_view_index_drop, 4);
-  rb_define_method(cBackend, "view_index_upsert", cb_Backend_view_index_upsert, 4);
+  rb_define_method(cBackend, "view_index_get_all", cb_Backend_view_index_get_all, 4);
+  rb_define_method(cBackend, "view_index_get", cb_Backend_view_index_get, 5);
+  rb_define_method(cBackend, "view_index_drop", cb_Backend_view_index_drop, 5);
+  rb_define_method(cBackend, "view_index_upsert", cb_Backend_view_index_upsert, 5);
 }
 } // namespace couchbase::ruby

data/lib/active_support/cache/couchbase_store.rb

@@ -180,11 +180,11 @@ module ActiveSupport
         end
       end
 
-      def serialize_entry(entry, raw: false, **options)
+      def serialize_entry(entry, raw: false, **)
         if raw
           entry.value.to_s
         else
-          super(entry, **options)
+          super(entry, **)
         end
       end
 
@@ -195,8 +195,8 @@ module ActiveSupport
       end
 
       # Reads an entry from the cache
-      def read_entry(key, **options)
-        deserialize_entry(read_serialized_entry(key, **options), **options)
+      def read_entry(key, **)
+        deserialize_entry(read_serialized_entry(key, **), **)
       end
 
       def read_serialized_entry(key, **)
@@ -228,8 +228,8 @@ module ActiveSupport
       end
 
       # Writes an entry to the cache
-      def write_entry(key, entry, raw: false, **options)
-        write_serialized_entry(key, serialize_entry(entry, raw: raw, **options), raw: raw, **options)
+      def write_entry(key, entry, raw: false, **)
+        write_serialized_entry(key, serialize_entry(entry, raw: raw, **), raw: raw, **)
       end
 
       def write_serialized_entry(key, payload, expires_in: nil, race_condition_ttl: nil, raw: false, **)

data/lib/couchbase/authenticator.rb

@@ -63,4 +63,18 @@ module Couchbase
       @key_path = key_path
     end
   end
+
+  # Authenticator using a JSON Web Token (JWT)
+  #
+  # @!macro uncommitted
+  class JWTAuthenticator
+    attr_accessor :token
+
+    # Creates a new authenticator with a JSON Web Token (JWT)
+    #
+    # @param [String] token the JWT
+    def initialize(token)
+      @token = token
+    end
+  end
 end