couchbase 3.1.0 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6610fe0ac9f660835b0bfaf36f53673e35213f29440ceda426bfb6f488195b95
-  data.tar.gz: 734c1253fae466f3698046cf37d532f4ec754d2ed35d7d5c37c48539a59ce9ee
+  metadata.gz: 24cc8f415bbff9e3e132ee47c16e04a2090c8a26cc9afbd21899263f735a10cd
+  data.tar.gz: 3e26641abb3b31354b496effc0002794c82af25a5626ccd784591f311c03c2c8
 SHA512:
-  metadata.gz: d8ef7b9f1c6f417b4e803f12b64682980dcc9f69c8ebfc462b72dbeb60e306ee6a33176ca320cd85bd9974ff5b457d51e26ebf7dfbe2251bb6bbfd1a92b12077
-  data.tar.gz: 8ce0c1aab3a6f48295bf5a312a4bda8bc6668b3de079b60c4549bb8c1e27662eac49284c218928d5ffb60b7af799a01cdab736ae8d484eebc17e1b23b360aa8f
+  metadata.gz: 7f57fb43563e563c4d0ab75330108a199ec63c36794ceb3afe0b5702cf117a2350b3e9b02027ea1129de8a3e4cc464248284a8973d6c4d442ce8f83fc69d84b0
+  data.tar.gz: b020a7a1049d9d63d64684e83c82c7b8c8aae90a80188e79eb09850e6c7bad242ce4642be0051ed6355b3789c5bb7a0253523218b5917bb4f78e208b3edcd30e

data/README.md

@@ -24,7 +24,7 @@ The library tested with the MRI 2.5, 2.6, 2.7 and 3.0. Supported platforms are L
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "couchbase", "3.1.0"
+gem "couchbase", "3.1.1"
 ```
 
 And then execute:

data/ext/build_version.hxx.in

@@ -26,5 +26,5 @@ constexpr auto BACKEND_CXX_COMPILER = "@CMAKE_CXX_COMPILER_ID@ @CMAKE_CXX_COMPIL
 constexpr auto BACKEND_C_COMPILER = "@CMAKE_C_COMPILER_ID@ @CMAKE_C_COMPILER_VERSION@";
 constexpr auto BACKEND_SYSTEM = "@CMAKE_SYSTEM@";
 constexpr auto BACKEND_SYSTEM_PROCESSOR = "@CMAKE_SYSTEM_PROCESSOR@";
-constexpr auto BACKEND_GIT_REVISION = "7ba4f7d8b5b0b59b9971ad765876413be3064adb";
+constexpr auto BACKEND_GIT_REVISION = "a79d098eb238b3883e49e1738c35167642e8834f";
 } // namespace couchbase

data/ext/couchbase/cluster_options.hxx

@@ -42,6 +42,7 @@ struct cluster_options {
     bool show_queries{ false };
     bool enable_unordered_execution{ true };
     bool enable_clustermap_notification{ true };
+    bool enable_compression{ true };
     std::string network{ "auto" };
 
     std::chrono::milliseconds tcp_keep_alive_interval = timeout_defaults::tcp_keep_alive_interval;

data/ext/couchbase/couchbase.cxx

@@ -2037,6 +2037,10 @@ cb_Backend_document_upsert(VALUE self, VALUE bucket, VALUE collection, VALUE id,
         if (!NIL_P(expiry)) {
             req.expiry = FIX2UINT(expiry);
         }
+        exc = cb_extract_option_bool(req.preserve_expiry, options, "preserve_expiry");
+        if (!NIL_P(exc)) {
+            break;
+        }
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::upsert_response>>();
         auto f = barrier->get_future();
@@ -2083,6 +2087,11 @@ cb_Backend_document_upsert_multi(VALUE self, VALUE id_content, VALUE options)
         if (!NIL_P(exc)) {
             break;
         }
+        bool preserve_expiry{ false };
+        exc = cb_extract_option_bool(preserve_expiry, options, "preserve_expiry");
+        if (!NIL_P(exc)) {
+            break;
+        }
 
         std::vector<std::tuple<couchbase::document_id, std::string, std::uint32_t>> tuples{};
         exc = cb_extract_array_of_id_content(tuples, id_content);
@@ -2105,6 +2114,7 @@ cb_Backend_document_upsert_multi(VALUE self, VALUE id_content, VALUE options)
             if (!NIL_P(expiry)) {
                 req.expiry = FIX2UINT(expiry);
             }
+            req.preserve_expiry = preserve_expiry;
             auto barrier = std::make_shared<std::promise<couchbase::operations::upsert_response>>();
             backend->cluster->execute(req, [barrier](couchbase::operations::upsert_response&& resp) mutable { barrier->set_value(resp); });
             barriers.emplace_back(barrier);
@@ -2276,6 +2286,10 @@ cb_Backend_document_replace(VALUE self, VALUE bucket, VALUE collection, VALUE id
         if (!NIL_P(expiry)) {
             req.expiry = FIX2UINT(expiry);
         }
+        exc = cb_extract_option_bool(req.preserve_expiry, options, "preserve_expiry");
+        if (!NIL_P(exc)) {
+            break;
+        }
         VALUE cas = Qnil;
         exc = cb_extract_option_bignum(cas, options, "cas");
         if (!NIL_P(exc)) {
@@ -2547,6 +2561,10 @@ cb_Backend_document_increment(VALUE self, VALUE bucket, VALUE collection, VALUE
         if (!NIL_P(expiry)) {
             req.expiry = FIX2UINT(expiry);
         }
+        exc = cb_extract_option_bool(req.preserve_expiry, options, "preserve_expiry");
+        if (!NIL_P(exc)) {
+            break;
+        }
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::increment_response>>();
         auto f = barrier->get_future();
@@ -2622,6 +2640,10 @@ cb_Backend_document_decrement(VALUE self, VALUE bucket, VALUE collection, VALUE
         if (!NIL_P(expiry)) {
             req.expiry = FIX2UINT(expiry);
         }
+        exc = cb_extract_option_bool(req.preserve_expiry, options, "preserve_expiry");
+        if (!NIL_P(exc)) {
+            break;
+        }
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::decrement_response>>();
         auto f = barrier->get_future();
@@ -2685,6 +2707,9 @@ cb_map_subdoc_opcode(couchbase::protocol::subdoc_opcode opcode)
         case couchbase::protocol::subdoc_opcode::set_doc:
             return rb_id2sym(rb_intern("set_doc"));
 
+        case couchbase::protocol::subdoc_opcode::remove_doc:
+            return rb_id2sym(rb_intern("remove_doc"));
+
         case couchbase::protocol::subdoc_opcode::replace_body_with_xattr:
             return rb_id2sym(rb_intern("replace_body_with_xattr"));
     }
@@ -2973,6 +2998,10 @@ cb_Backend_document_mutate_in(VALUE self, VALUE bucket, VALUE collection, VALUE
         if (!NIL_P(expiry)) {
             req.expiry = FIX2UINT(expiry);
         }
+        exc = cb_extract_option_bool(req.preserve_expiry, options, "preserve_expiry");
+        if (!NIL_P(exc)) {
+            break;
+        }
         exc = cb_extract_option_bool(req.access_deleted, options, "access_deleted");
         if (!NIL_P(exc)) {
             break;
@@ -3023,6 +3052,8 @@ cb_Backend_document_mutate_in(VALUE self, VALUE bucket, VALUE collection, VALUE
                 opcode = couchbase::protocol::subdoc_opcode::counter;
             } else if (operation_id == rb_intern("set_doc")) {
                 opcode = couchbase::protocol::subdoc_opcode::set_doc;
+            } else if (operation_id == rb_intern("remove_doc")) {
+                opcode = couchbase::protocol::subdoc_opcode::remove_doc;
             } else {
                 exc =
                   rb_exc_new_str(eInvalidArgument, rb_sprintf("unsupported operation for subdocument mutation: %+" PRIsVALUE, operation));

data/ext/couchbase/io/mcbp_session.hxx

@@ -139,6 +139,9 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
             if (session_->origin_.options().enable_clustermap_notification) {
                 hello_req.body().enable_clustermap_change_notification();
             }
+            if (session_->origin_.options().enable_compression) {
+                hello_req.body().enable_compression();
+            }
             hello_req.opaque(session_->next_opaque());
             hello_req.body().user_agent(tao::json::to_string(user_agent));
             spdlog::debug("{} user_agent={}, requested_features=[{}]",

data/ext/couchbase/operations/collection_create.hxx

@@ -60,27 +60,31 @@ struct collection_create_request {
 };
 
 collection_create_response
-make_response(error_context::http&& ctx, collection_create_request&, collection_create_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx,
+              collection_create_request& /* request */,
+              collection_create_request::encoded_response_type&& encoded)
 {
     collection_create_response response{ ctx };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
-            case 400:
-                if (encoded.body.find("Collection with this name already exists") != std::string::npos) {
+            case 400: {
+                std::regex collection_exists("Collection with name .+ already exists");
+                if (std::regex_search(encoded.body, collection_exists)) {
                     response.ctx.ec = std::make_error_code(error::management_errc::collection_exists);
                 } else if (encoded.body.find("Not allowed on this version of cluster") != std::string::npos) {
                     response.ctx.ec = std::make_error_code(error::common_errc::feature_not_available);
                 } else {
                     response.ctx.ec = std::make_error_code(error::common_errc::invalid_argument);
                 }
-                break;
-            case 404:
-                if (encoded.body.find("Scope with this name is not found") != std::string::npos) {
+            } break;
+            case 404: {
+                std::regex scope_not_found("Scope with name .+ is not found");
+                if (std::regex_search(encoded.body, scope_not_found)) {
                     response.ctx.ec = std::make_error_code(error::common_errc::scope_not_found);
                 } else {
                     response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
                 }
-                break;
+            } break;
             case 200: {
                 tao::json::value payload{};
                 try {

data/ext/couchbase/operations/collection_drop.hxx

@@ -17,6 +17,8 @@
 
 #pragma once
 
+#include <regex>
+
 #include <tao/json.hpp>
 
 #include <version.hxx>
@@ -54,7 +56,7 @@ struct collection_drop_request {
 };
 
 collection_drop_response
-make_response(error_context::http&& ctx, collection_drop_request&, collection_drop_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, collection_drop_request& /* request */, collection_drop_request::encoded_response_type&& encoded)
 {
     collection_drop_response response{ ctx };
     if (!response.ctx.ec) {
@@ -62,15 +64,17 @@ make_response(error_context::http&& ctx, collection_drop_request&, collection_dr
             case 400:
                 response.ctx.ec = std::make_error_code(error::common_errc::unsupported_operation);
                 break;
-            case 404:
-                if (encoded.body.find("Collection with this name is not found") != std::string::npos) {
+            case 404: {
+                std::regex scope_not_found("Scope with name .+ is not found");
+                std::regex collection_not_found("Collection with name .+ is not found");
+                if (std::regex_search(encoded.body, collection_not_found)) {
                     response.ctx.ec = std::make_error_code(error::common_errc::collection_not_found);
-                } else if (encoded.body.find("Scope with this name is not found") != std::string::npos) {
+                } else if (std::regex_search(encoded.body, scope_not_found)) {
                     response.ctx.ec = std::make_error_code(error::common_errc::scope_not_found);
                 } else {
                     response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
                 }
-                break;
+            } break;
             case 200: {
                 tao::json::value payload{};
                 try {

data/ext/couchbase/operations/document_decrement.hxx

@@ -45,6 +45,7 @@ struct decrement_request {
     std::optional<std::uint16_t> durability_timeout{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
+    bool preserve_expiry{ false };
 
     [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
     {
@@ -62,6 +63,9 @@ struct decrement_request {
         if (durability_level != protocol::durability_level::none) {
             encoded.body().durability(durability_level, durability_timeout);
         }
+        if (preserve_expiry) {
+            encoded.body().preserve_expiry();
+        }
         return {};
     }
 };

data/ext/couchbase/operations/document_increment.hxx

@@ -47,6 +47,7 @@ struct increment_request {
     std::optional<std::uint16_t> durability_timeout{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
+    bool preserve_expiry{ false };
 
     [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
     {
@@ -64,6 +65,9 @@ struct increment_request {
         if (durability_level != protocol::durability_level::none) {
             encoded.body().durability(durability_level, durability_timeout);
         }
+        if (preserve_expiry) {
+            encoded.body().preserve_expiry();
+        }
         return {};
     }
 };

data/ext/couchbase/operations/document_mutate_in.hxx

@@ -70,6 +70,7 @@ struct mutate_in_request {
     std::optional<std::uint16_t> durability_timeout{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
+    bool preserve_expiry{ false };
 
     [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& ctx)
     {
@@ -102,6 +103,9 @@ struct mutate_in_request {
         if (durability_level != protocol::durability_level::none) {
             encoded.body().durability(durability_level, durability_timeout);
         }
+        if (preserve_expiry) {
+            encoded.body().preserve_expiry();
+        }
         return {};
     }
 };

data/ext/couchbase/operations/document_query.hxx

@@ -380,6 +380,7 @@ make_response(error_context::query&& ctx, query_request& request, query_request:
             bool syntax_error = false;
             bool server_timeout = false;
             bool invalid_argument = false;
+            bool cas_mismatch = false;
 
             if (response.payload.meta_data.errors) {
                 for (const auto& error : *response.payload.meta_data.errors) {
@@ -401,6 +402,11 @@ make_response(error_context::query&& ctx, query_request& request, query_request:
                         case 4090: /* IKey: "plan.build_prepared.name_not_in_encoded_plan" */
                             prepared_statement_failure = true;
                             break;
+                        case 12009: /* IKey: "datastore.couchbase.DML_error" */
+                            if (error.message.find("CAS mismatch") != std::string::npos) {
+                                cas_mismatch = true;
+                            }
+                            break;
                         case 12004: /* IKey: "datastore.couchbase.primary_idx_not_found" */
                         case 12016: /* IKey: "datastore.couchbase.index_not_found" */
                             index_not_found = true;
@@ -429,6 +435,8 @@ make_response(error_context::query&& ctx, query_request& request, query_request:
                 response.ctx.ec = std::make_error_code(error::query_errc::planning_failure);
             } else if (index_not_found) {
                 response.ctx.ec = std::make_error_code(error::common_errc::index_not_found);
+            } else if (cas_mismatch) {
+                response.ctx.ec = std::make_error_code(error::common_errc::cas_mismatch);
             } else {
                 response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
             }

data/ext/couchbase/operations/document_replace.hxx

@@ -46,6 +46,7 @@ struct replace_request {
     std::optional<std::uint16_t> durability_timeout{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
+    bool preserve_expiry{ false };
 
     [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
     {
@@ -59,6 +60,9 @@ struct replace_request {
         if (durability_level != protocol::durability_level::none) {
             encoded.body().durability(durability_level, durability_timeout);
         }
+        if (preserve_expiry) {
+            encoded.body().preserve_expiry();
+        }
         return {};
     }
 };

data/ext/couchbase/operations/document_upsert.hxx

@@ -45,6 +45,7 @@ struct upsert_request {
     std::optional<std::uint16_t> durability_timeout{};
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
+    bool preserve_expiry{ false };
 
     [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
     {
@@ -57,6 +58,9 @@ struct upsert_request {
         if (durability_level != protocol::durability_level::none) {
             encoded.body().durability(durability_level, durability_timeout);
         }
+        if (preserve_expiry) {
+            encoded.body().preserve_expiry();
+        }
         return {};
     }
 };

data/ext/couchbase/operations/scope_create.hxx

@@ -17,6 +17,8 @@
 
 #pragma once
 
+#include <regex>
+
 #include <tao/json.hpp>
 
 #include <version.hxx>
@@ -55,22 +57,21 @@ struct scope_create_request {
 };
 
 scope_create_response
-make_response(error_context::http&& ctx, scope_create_request&, scope_create_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, scope_create_request& /* request */, scope_create_request::encoded_response_type&& encoded)
 {
     scope_create_response response{ ctx };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
-            case 400:
-                if (encoded.body.find("Not allowed on this version") != std::string::npos) {
-                    response.ctx.ec = std::make_error_code(error::common_errc::unsupported_operation);
-                } else if (encoded.body.find("Scope with this name already exists") != std::string::npos) {
+            case 400: {
+                std::regex scope_exists("Scope with name .+ already exists");
+                if (std::regex_search(encoded.body, scope_exists)) {
                     response.ctx.ec = std::make_error_code(error::management_errc::scope_exists);
                 } else if (encoded.body.find("Not allowed on this version of cluster") != std::string::npos) {
                     response.ctx.ec = std::make_error_code(error::common_errc::feature_not_available);
                 } else {
                     response.ctx.ec = std::make_error_code(error::common_errc::invalid_argument);
                 }
-                break;
+            } break;
             case 404:
                 response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
                 break;

data/ext/couchbase/operations/scope_drop.hxx

@@ -17,6 +17,8 @@
 
 #pragma once
 
+#include <regex>
+
 #include <tao/json.hpp>
 
 #include <version.hxx>
@@ -53,7 +55,7 @@ struct scope_drop_request {
 };
 
 scope_drop_response
-make_response(error_context::http&& ctx, scope_drop_request&, scope_drop_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, scope_drop_request& /* request */, scope_drop_request::encoded_response_type&& encoded)
 {
     scope_drop_response response{ ctx };
     if (!response.ctx.ec) {
@@ -61,13 +63,14 @@ make_response(error_context::http&& ctx, scope_drop_request&, scope_drop_request
             case 400:
                 response.ctx.ec = std::make_error_code(error::common_errc::unsupported_operation);
                 break;
-            case 404:
-                if (encoded.body.find("Scope with this name is not found") != std::string::npos) {
+            case 404: {
+                std::regex scope_not_found("Scope with name .+ is not found");
+                if (std::regex_search(encoded.body, scope_not_found)) {
                     response.ctx.ec = std::make_error_code(error::common_errc::scope_not_found);
                 } else {
                     response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
                 }
-                break;
+            } break;
             case 200: {
                 tao::json::value payload{};
                 try {

data/ext/couchbase/protocol/client_opcode.hxx

@@ -233,6 +233,7 @@ enum class client_opcode : uint8_t {
 enum class subdoc_opcode : uint8_t {
     get_doc = 0x00,
     set_doc = 0x01,
+    remove_doc = 0x04,
     get = 0xc5,
     exists = 0xc6,
     dict_add = 0xc7,
@@ -345,6 +346,7 @@ is_valid_subdoc_opcode(uint8_t code)
         case subdoc_opcode::get_count:
         case subdoc_opcode::get_doc:
         case subdoc_opcode::set_doc:
+        case subdoc_opcode::remove_doc:
         case subdoc_opcode::replace_body_with_xattr:
             return true;
     }
@@ -626,6 +628,9 @@ struct fmt::formatter<couchbase::protocol::subdoc_opcode> : formatter<string_vie
             case couchbase::protocol::subdoc_opcode::replace_body_with_xattr:
                 name = "replace_body_with_xattr (0xd3)";
                 break;
+            case couchbase::protocol::subdoc_opcode::remove_doc:
+                name = "remove_doc (0x04)";
+                break;
         }
         return formatter<string_view>::format(name, ctx);
     }

data/ext/couchbase/protocol/cmd_decrement.hxx

@@ -48,7 +48,7 @@ class decrement_response_body
     bool parse(protocol::status status,
                const header_buffer& header,
                std::uint8_t framing_extras_size,
-               std::uint16_t /* key_size */,
+               std::uint16_t key_size,
                std::uint8_t extras_size,
                const std::vector<uint8_t>& body,
                const cmd_info&)
@@ -66,6 +66,7 @@ class decrement_response_body
                 token_.sequence_number = utils::byte_swap_64(token_.sequence_number);
                 offset += 8;
             }
+            offset += key_size;
             memcpy(&content_, body.data() + offset, sizeof(content_));
             content_ = utils::byte_swap_64(content_);
             return true;
@@ -119,19 +120,28 @@ class decrement_request_body
             return;
         }
         auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::durability_requirement);
+        auto extras_size = framing_extras_.size();
         if (timeout) {
-            framing_extras_.resize(4);
-            framing_extras_[0] = static_cast<std::uint8_t>((static_cast<std::uint32_t>(frame_id) << 4U) | 3U);
-            framing_extras_[1] = static_cast<std::uint8_t>(level);
+            framing_extras_.resize(extras_size + 4);
+            framing_extras_[extras_size + 0] = static_cast<std::uint8_t>((static_cast<std::uint32_t>(frame_id) << 4U) | 3U);
+            framing_extras_[extras_size + 1] = static_cast<std::uint8_t>(level);
             uint16_t val = htons(*timeout);
-            memcpy(framing_extras_.data() + 2, &val, sizeof(val));
+            memcpy(framing_extras_.data() + extras_size + 2, &val, sizeof(val));
         } else {
-            framing_extras_.resize(2);
-            framing_extras_[0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 1U);
-            framing_extras_[1] = static_cast<std::uint8_t>(level);
+            framing_extras_.resize(extras_size + 2);
+            framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 1U);
+            framing_extras_[extras_size + 1] = static_cast<std::uint8_t>(level);
         }
     }
 
+    void preserve_expiry()
+    {
+        auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::preserve_ttl);
+        auto extras_size = framing_extras_.size();
+        framing_extras_.resize(extras_size + 1);
+        framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 0U);
+    }
+
     const std::string& key()
     {
         return key_;

data/ext/couchbase/protocol/cmd_hello.hxx

@@ -80,7 +80,6 @@ class hello_request_body
         hello_feature::xattr,
         hello_feature::xerror,
         hello_feature::select_bucket,
-        hello_feature::snappy,
         hello_feature::json,
         hello_feature::duplex,
         hello_feature::alt_request_support,
@@ -89,6 +88,7 @@ class hello_request_body
         hello_feature::vattr,
         hello_feature::collections,
         hello_feature::subdoc_create_as_deleted,
+        hello_feature::preserve_ttl,
     };
     std::vector<std::uint8_t> value_;
 
@@ -113,6 +113,11 @@ class hello_request_body
         features_.emplace_back(hello_feature::clustermap_change_notification);
     }
 
+    void enable_compression()
+    {
+        features_.emplace_back(hello_feature::snappy);
+    }
+
     [[nodiscard]] const std::vector<hello_feature>& features() const
     {
         return features_;

data/ext/couchbase/protocol/cmd_increment.hxx

@@ -48,7 +48,7 @@ class increment_response_body
     bool parse(protocol::status status,
                const header_buffer& header,
                std::uint8_t framing_extras_size,
-               std::uint16_t /* key_size */,
+               std::uint16_t key_size,
                std::uint8_t extras_size,
                const std::vector<uint8_t>& body,
                const cmd_info&)
@@ -66,6 +66,7 @@ class increment_response_body
                 token_.sequence_number = utils::byte_swap_64(token_.sequence_number);
                 offset += 8;
             }
+            offset += key_size;
             memcpy(&content_, body.data() + offset, sizeof(content_));
             content_ = utils::byte_swap_64(content_);
             return true;
@@ -119,19 +120,28 @@ class increment_request_body
             return;
         }
         auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::durability_requirement);
+        auto extras_size = framing_extras_.size();
         if (timeout) {
-            framing_extras_.resize(4);
-            framing_extras_[0] = static_cast<std::uint8_t>((static_cast<std::uint32_t>(frame_id) << 4U) | 3U);
-            framing_extras_[1] = static_cast<std::uint8_t>(level);
+            framing_extras_.resize(extras_size + 4);
+            framing_extras_[extras_size + 0] = static_cast<std::uint8_t>((static_cast<std::uint32_t>(frame_id) << 4U) | 3U);
+            framing_extras_[extras_size + 1] = static_cast<std::uint8_t>(level);
             uint16_t val = htons(*timeout);
-            memcpy(framing_extras_.data() + 2, &val, sizeof(val));
+            memcpy(framing_extras_.data() + extras_size + 2, &val, sizeof(val));
         } else {
-            framing_extras_.resize(2);
-            framing_extras_[0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 1U);
-            framing_extras_[1] = static_cast<std::uint8_t>(level);
+            framing_extras_.resize(extras_size + 2);
+            framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 1U);
+            framing_extras_[extras_size + 1] = static_cast<std::uint8_t>(level);
         }
     }
 
+    void preserve_expiry()
+    {
+        auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::preserve_ttl);
+        auto extras_size = framing_extras_.size();
+        framing_extras_.resize(extras_size + 1);
+        framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 0U);
+    }
+
     const std::string& key()
     {
         return key_;

data/ext/couchbase/protocol/cmd_mutate_in.hxx

@@ -224,7 +224,7 @@ class mutate_in_request_body
 
         void add_spec(subdoc_opcode operation, bool xattr, const std::string& path)
         {
-            Expects(operation == protocol::subdoc_opcode::remove);
+            Expects(operation == protocol::subdoc_opcode::remove || operation == protocol::subdoc_opcode::remove_doc);
             add_spec(static_cast<std::uint8_t>(operation), build_path_flags(xattr, false, false), path, "");
         }
 
@@ -305,19 +305,28 @@ class mutate_in_request_body
             return;
         }
         auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::durability_requirement);
+        auto extras_size = framing_extras_.size();
         if (timeout) {
-            framing_extras_.resize(4);
-            framing_extras_[0] = static_cast<std::uint8_t>((static_cast<std::uint32_t>(frame_id) << 4U) | 3U);
-            framing_extras_[1] = static_cast<std::uint8_t>(level);
+            framing_extras_.resize(extras_size + 4);
+            framing_extras_[extras_size + 0] = static_cast<std::uint8_t>((static_cast<std::uint32_t>(frame_id) << 4U) | 3U);
+            framing_extras_[extras_size + 1] = static_cast<std::uint8_t>(level);
             uint16_t val = htons(*timeout);
-            memcpy(framing_extras_.data() + 2, &val, sizeof(val));
+            memcpy(framing_extras_.data() + extras_size + 2, &val, sizeof(val));
         } else {
-            framing_extras_.resize(2);
-            framing_extras_[0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 1U);
-            framing_extras_[1] = static_cast<std::uint8_t>(level);
+            framing_extras_.resize(extras_size + 2);
+            framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 1U);
+            framing_extras_[extras_size + 1] = static_cast<std::uint8_t>(level);
         }
     }
 
+    void preserve_expiry()
+    {
+        auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::preserve_ttl);
+        auto extras_size = framing_extras_.size();
+        framing_extras_.resize(extras_size + 1);
+        framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 0U);
+    }
+
     const std::string& key()
     {
         return key_;

data/ext/couchbase/protocol/cmd_replace.hxx

@@ -97,19 +97,28 @@ class replace_request_body
             return;
         }
         auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::durability_requirement);
+        auto extras_size = framing_extras_.size();
         if (timeout) {
-            framing_extras_.resize(4);
-            framing_extras_[0] = static_cast<std::uint8_t>((static_cast<std::uint32_t>(frame_id) << 4U) | 3U);
-            framing_extras_[1] = static_cast<std::uint8_t>(level);
+            framing_extras_.resize(extras_size + 4);
+            framing_extras_[extras_size + 0] = static_cast<std::uint8_t>((static_cast<std::uint32_t>(frame_id) << 4U) | 3U);
+            framing_extras_[extras_size + 1] = static_cast<std::uint8_t>(level);
             uint16_t val = htons(*timeout);
-            memcpy(framing_extras_.data() + 2, &val, sizeof(val));
+            memcpy(framing_extras_.data() + extras_size + 2, &val, sizeof(val));
         } else {
-            framing_extras_.resize(2);
-            framing_extras_[0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 1U);
-            framing_extras_[1] = static_cast<std::uint8_t>(level);
+            framing_extras_.resize(extras_size + 2);
+            framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 1U);
+            framing_extras_[extras_size + 1] = static_cast<std::uint8_t>(level);
         }
     }
 
+    void preserve_expiry()
+    {
+        auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::preserve_ttl);
+        auto extras_size = framing_extras_.size();
+        framing_extras_.resize(extras_size + 1);
+        framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 0U);
+    }
+
     void content(const std::string& content)
     {
         content_ = { content.begin(), content.end() };

data/ext/couchbase/protocol/cmd_upsert.hxx

@@ -97,19 +97,28 @@ class upsert_request_body
             return;
         }
         auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::durability_requirement);
+        auto extras_size = framing_extras_.size();
         if (timeout) {
-            framing_extras_.resize(4);
-            framing_extras_[0] = static_cast<std::uint8_t>((static_cast<std::uint32_t>(frame_id) << 4U) | 3U);
-            framing_extras_[1] = static_cast<std::uint8_t>(level);
+            framing_extras_.resize(extras_size + 4);
+            framing_extras_[extras_size + 0] = static_cast<std::uint8_t>((static_cast<std::uint32_t>(frame_id) << 4U) | 3U);
+            framing_extras_[extras_size + 1] = static_cast<std::uint8_t>(level);
             uint16_t val = htons(*timeout);
-            memcpy(framing_extras_.data() + 2, &val, sizeof(val));
+            memcpy(framing_extras_.data() + extras_size + 2, &val, sizeof(val));
         } else {
-            framing_extras_.resize(2);
-            framing_extras_[0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 1U);
-            framing_extras_[1] = static_cast<std::uint8_t>(level);
+            framing_extras_.resize(extras_size + 2);
+            framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 1U);
+            framing_extras_[extras_size + 1] = static_cast<std::uint8_t>(level);
         }
     }
 
+    void preserve_expiry()
+    {
+        auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::preserve_ttl);
+        auto extras_size = framing_extras_.size();
+        framing_extras_.resize(extras_size + 1);
+        framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 0U);
+    }
+
     void content(const std::string& content)
     {
         content_ = { content.begin(), content.end() };

data/ext/couchbase/protocol/frame_info_id.hxx

@@ -90,7 +90,7 @@ enum class request_frame_info_id : uint8_t {
      * If the request modifies an existing document the expiry time from the existing document should be used instead of the TTL provided.
      * If document don't exist the provided TTL should be used. The frame info contains no value (length = 0).
      */
-    preserve_ttl = 0x1f,
+    preserve_ttl = 0x05,
 };
 
 constexpr inline bool

data/ext/couchbase/utils/connection_string.hxx

@@ -348,6 +348,15 @@ extract_options(connection_string& connstr)
                 } else if (param.second == "false" || param.second == "no" || param.second == "off") {
                     connstr.options.enable_unordered_execution = false;
                 }
+            } else if (param.first == "enable_compression") {
+                /**
+                 * Announce support of compression (snappy) to server
+                 */
+                if (param.second == "true" || param.second == "yes" || param.second == "on") {
+                    connstr.options.enable_compression = true;
+                } else if (param.second == "false" || param.second == "no" || param.second == "off") {
+                    connstr.options.enable_compression = false;
+                }
             } else {
                 spdlog::warn(R"(unknown parameter "{}" in connection string (value "{}"))", param.first, param.second);
             }

data/ext/couchbase/version.hxx

@@ -24,7 +24,7 @@
 namespace couchbase
 {
 constexpr auto BACKEND_VERSION_MAJOR = 1;
-constexpr auto BACKEND_VERSION_MINOR = 4;
+constexpr auto BACKEND_VERSION_MINOR = 5;
 constexpr auto BACKEND_VERSION_PATCH = 0;
 
 inline const std::string&

data/lib/active_support/cache/couchbase_store.rb

@@ -13,6 +13,7 @@
 #  limitations under the License.
 
 require "couchbase"
+require "digest/sha2"
 
 module ActiveSupport
   module Cache

data/lib/couchbase/options.rb

@@ -507,10 +507,13 @@ module Couchbase
       attr_accessor :expiry # @return [Integer, #in_seconds, nil]
       attr_accessor :transcoder # @return [JsonTranscoder, #encode(Object)]
       attr_accessor :durability_level # @return [Symbol]
+      attr_accessor :preserve_expiry # @return [Boolean]
 
       # Creates an instance of options for {Collection#upsert}
       #
       # @param [Integer, #in_seconds, Time, nil] expiry expiration time to associate with the document
+      # @param [Boolean] preserve_expiry if true and the document exists, the server will preserve current expiration
+      #  for the document, otherwise will use {expiry} from the operation.
       # @param [JsonTranscoder, #encode(Object)] transcoder used for encoding
       # @param [Symbol] durability_level level of durability
       #  +:none+::
@@ -533,6 +536,7 @@ module Couchbase
       #
       # @yieldparam [Upsert]
       def initialize(expiry: nil,
+                     preserve_expiry: false,
                      transcoder: JsonTranscoder.new,
                      durability_level: :none,
                      timeout: nil,
@@ -541,6 +545,7 @@ module Couchbase
                      parent_span: nil)
         super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
         @expiry = Utils::Time.extract_expiry_time(expiry)
+        @preserve_expiry = preserve_expiry
         @transcoder = transcoder
         @durability_level = durability_level
         yield self if block_given?
@@ -550,6 +555,7 @@ module Couchbase
         {
           timeout: @timeout.respond_to?(:in_milliseconds) ? @timeout.public_send(:in_milliseconds) : @timeout,
           expiry: @expiry,
+          preserve_expiry: @preserve_expiry,
           durability_level: @durability_level,
         }
       end
@@ -560,10 +566,13 @@ module Couchbase
       attr_accessor :expiry # @return [Integer, #in_seconds, nil]
       attr_accessor :transcoder # @return [JsonTranscoder, #encode(Object)]
       attr_accessor :durability_level # @return [Symbol]
+      attr_accessor :preserve_expiry # @return [Boolean]
 
       # Creates an instance of options for {Collection#upsert}
       #
       # @param [Integer, #in_seconds, Time, nil] expiry expiration time to associate with the document
+      # @param [Boolean] preserve_expiry if true and the document exists, the server will preserve current expiration
+      #  for the document, otherwise will use {expiry} from the operation.
       # @param [JsonTranscoder, #encode(Object)] transcoder used for encoding
       # @param [Symbol] durability_level level of durability
       #  +:none+::
@@ -586,6 +595,7 @@ module Couchbase
       #
       # @yieldparam [Upsert]
       def initialize(expiry: nil,
+                     preserve_expiry: false,
                      transcoder: JsonTranscoder.new,
                      durability_level: :none,
                      timeout: nil,
@@ -594,6 +604,7 @@ module Couchbase
                      parent_span: nil)
         super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
         @expiry = Utils::Time.extract_expiry_time(expiry)
+        @preserve_expiry = preserve_expiry
         @transcoder = transcoder
         @durability_level = durability_level
         yield self if block_given?
@@ -603,6 +614,7 @@ module Couchbase
         {
           timeout: @timeout.respond_to?(:in_milliseconds) ? @timeout.public_send(:in_milliseconds) : @timeout,
           expiry: @expiry,
+          preserve_expiry: @preserve_expiry,
           durability_level: @durability_level,
         }
       end
@@ -614,10 +626,13 @@ module Couchbase
       attr_accessor :transcoder # @return [JsonTranscoder, #encode(Object)]
       attr_accessor :cas # @return [Integer, nil]
       attr_accessor :durability_level # @return [Symbol]
+      attr_accessor :preserve_expiry # @return [Boolean]
 
       # Creates an instance of options for {Collection#replace}
       #
       # @param [Integer, #in_seconds, nil] expiry expiration time to associate with the document
+      # @param [Boolean] preserve_expiry if true and the document exists, the server will preserve current expiration
+      #  for the document, otherwise will use {expiry} from the operation.
       # @param [JsonTranscoder, #encode(Object)] transcoder used for encoding
       # @param [Integer, nil] cas a CAS value that will be taken into account on the server side for optimistic concurrency
       # @param [Symbol] durability_level level of durability
@@ -641,6 +656,7 @@ module Couchbase
       #
       # @yieldparam [Replace]
       def initialize(expiry: nil,
+                     preserve_expiry: false,
                      transcoder: JsonTranscoder.new,
                      cas: nil,
                      durability_level: :none,
@@ -650,6 +666,7 @@ module Couchbase
                      parent_span: nil)
         super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
         @expiry = Utils::Time.extract_expiry_time(expiry)
+        @preserve_expiry = preserve_expiry
         @transcoder = transcoder
         @cas = cas
         @durability_level = durability_level
@@ -660,6 +677,7 @@ module Couchbase
         {
           timeout: @timeout.respond_to?(:in_milliseconds) ? @timeout.public_send(:in_milliseconds) : @timeout,
           expiry: @expiry,
+          preserve_expiry: @preserve_expiry,
           durability_level: @durability_level,
           cas: @cas,
         }
@@ -673,10 +691,13 @@ module Couchbase
       attr_accessor :cas # @return [Integer, nil]
       attr_accessor :durability_level # @return [Symbol]
       attr_accessor :transcoder # @return [JsonTranscoder, #encode(Object)]
+      attr_accessor :preserve_expiry # @return [Boolean]
 
       # Creates an instance of options for {Collection#mutate_in}
       #
       # @param [Integer, #in_seconds, Time, nil] expiry expiration time to associate with the document
+      # @param [Boolean] preserve_expiry if true and the document exists, the server will preserve current expiration
+      #  for the document, otherwise will use {expiry} from the operation.
       # @param [Symbol] store_semantics describes how the outer document store semantics on subdoc should act
       #  +:replace+:: replace the document, fail if it does not exist. This is the default
       #  +:upsert+:: replace the document or create if it does not exist
@@ -706,6 +727,7 @@ module Couchbase
       #
       # @yieldparam [MutateIn]
       def initialize(expiry: nil,
+                     preserve_expiry: false,
                      store_semantics: :replace,
                      cas: nil,
                      access_deleted: false,
@@ -718,6 +740,7 @@ module Couchbase
                      parent_span: nil)
         super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
         @expiry = Utils::Time.extract_expiry_time(expiry)
+        @preserve_expiry = preserve_expiry
         @store_semantics = store_semantics
         @cas = cas
         @access_deleted = access_deleted
@@ -732,6 +755,7 @@ module Couchbase
         {
           timeout: @timeout.respond_to?(:in_milliseconds) ? @timeout.public_send(:in_milliseconds) : @timeout,
           expiry: @expiry,
+          preserve_expiry: @preserve_expiry,
           durability_level: @durability_level,
           cas: @cas,
           store_semantics: @store_semantics,
@@ -862,12 +886,15 @@ module Couchbase
       attr_accessor :initial # @return [Integer]
       attr_accessor :expiry # @return [Integer, #in_seconds]
       attr_accessor :durability_level # @return [Symbol]
+      attr_accessor :preserve_expiry # @return [Boolean]
 
       # Creates an instance of options for {BinaryCollection#increment}
       #
       # @param [Integer] delta the delta for the operation
       # @param [Integer] initial if present, holds the initial value
       # @param [Integer, #in_seconds, Time, nil] expiry if set, holds the expiration for the operation
+      # @param [Boolean] preserve_expiry if true and the document exists, the server will preserve current expiration
+      #  for the document, otherwise will use {expiry} from the operation.
       # @param [Symbol] durability_level level of durability
       #  +:none+::
       #     no enhanced durability required for the mutation
@@ -891,6 +918,7 @@ module Couchbase
       def initialize(delta: 1,
                      initial: nil,
                      expiry: nil,
+                     preserve_expiry: false,
                      durability_level: :none,
                      timeout: nil,
                      retry_strategy: nil,
@@ -902,6 +930,7 @@ module Couchbase
         @delta = delta
         @initial = initial
         @expiry = Utils::Time.extract_expiry_time(expiry)
+        @preserve_expiry = preserve_expiry
         @durability_level = durability_level
         yield self if block_given?
       end
@@ -920,6 +949,7 @@ module Couchbase
           delta: @delta,
           initial_value: @initial,
           expiry: @expiry,
+          preserve_expiry: @preserve_expiry,
           durability_level: @durability_level,
         }
       end
@@ -931,12 +961,15 @@ module Couchbase
       attr_accessor :initial # @return [Integer]
       attr_accessor :expiry # @return [Integer, #in_seconds]
       attr_accessor :durability_level # @return [Symbol]
+      attr_accessor :preserve_expiry # @return [Boolean]
 
       # Creates an instance of options for {BinaryCollection#decrement}
       #
       # @param [Integer] delta the delta for the operation
       # @param [Integer] initial if present, holds the initial value
       # @param [Integer, #in_seconds, Time, nil] expiry if set, holds the expiration for the operation
+      # @param [Boolean] preserve_expiry if true and the document exists, the server will preserve current expiration
+      #  for the document, otherwise will use {expiry} from the operation.
       # @param [Symbol] durability_level level of durability
       #  +:none+::
       #     no enhanced durability required for the mutation
@@ -960,6 +993,7 @@ module Couchbase
       def initialize(delta: 1,
                      initial: nil,
                      expiry: nil,
+                     preserve_expiry: false,
                      durability_level: :none,
                      timeout: nil,
                      retry_strategy: nil,
@@ -971,6 +1005,7 @@ module Couchbase
         @delta = delta
         @initial = initial
         @expiry = Utils::Time.extract_expiry_time(expiry)
+        @preserve_expiry = preserve_expiry
         @durability_level = durability_level
         yield self if block_given?
       end
@@ -989,6 +1024,7 @@ module Couchbase
           delta: @delta,
           initial_value: @initial,
           expiry: @expiry,
+          preserve_expiry: @preserve_expiry,
           durability_level: @durability_level,
         }
       end

data/lib/couchbase/subdoc.rb

@@ -134,7 +134,7 @@ module Couchbase
     #
     # @return [MutateInSpec]
     def self.remove(path)
-      new(:remove, path, nil)
+      new(path.empty? ? :remove_doc : :remove, path, nil)
     end
 
     # Creates a command with the intention of upserting a value in a JSON object.

data/lib/couchbase/version.rb

@@ -17,21 +17,21 @@ module Couchbase
   #
   # @example Display version and all dependencies in command line
   #   # ruby -rcouchbase -e 'pp Couchbase::VERSION'
-  #   {:sdk=>"3.0.1",
-  #    :backend=>"1.1.0",
-  #    :build_timestamp=>"2020-10-05 11:19:50",
-  #    :revision=>"b59cb40f11ec2dba992eda285eae5cd7238a59c3",
+  #   {:sdk=>"3.1.0",
+  #    :backend=>"1.4.0",
+  #    :build_timestamp=>"2021-03-24 11:25:34",
+  #    :revision=>"7ba4f7d8b5b0b59b9971ad765876413be3064adb",
   #    :platform=>"Linux-4.15.0-66-generic",
   #    :cpu=>"x86_64",
   #    :cc=>"GNU 9.3.1",
   #    :cxx=>"GNU 9.3.1",
-  #    :ruby=>"2.7.0",
+  #    :ruby=>"3.0.0",
   #    :spdlog=>"1.8.1",
   #    :asio=>"1.18.0",
   #    :snappy=>"1.1.8",
   #    :http_parser=>"2.9.4",
-  #    :openssl_headers=>"OpenSSL 1.1.1c FIPS  28 May 2019",
-  #    :openssl_runtime=>"OpenSSL 1.1.1c FIPS  28 May 2019"}
+  #    :openssl_headers=>"OpenSSL 1.1.1g FIPS  21 Apr 2020",
+  #    :openssl_runtime=>"OpenSSL 1.1.1g FIPS  21 Apr 2020"}
   VERSION = {} unless defined?(VERSION) # rubocop:disable Style/MutableConstant
-  VERSION.update(:sdk => "3.1.0".freeze)
+  VERSION.update(:sdk => "3.1.1".freeze)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: couchbase
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.1.1
 platform: ruby
 authors:
 - Sergey Avseyev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-03-24 00:00:00.000000000 Z
+date: 2021-04-08 00:00:00.000000000 Z
 dependencies: []
 description: Modern SDK for Couchbase Server
 email:
@@ -1375,9 +1375,9 @@ metadata:
   homepage_uri: https://docs.couchbase.com/ruby-sdk/3.0/hello-world/start-using-sdk.html
   bug_tracker_uri: https://couchbase.com/issues/browse/RCBC
   mailing_list_uri: https://forums.couchbase.com/c/ruby-sdk
-  source_code_uri: https://github.com/couchbase/couchbase-ruby-client/tree/3.1.0
-  changelog_uri: https://github.com/couchbase/couchbase-ruby-client/releases/tag/3.1.0
-  documentation_uri: https://docs.couchbase.com/sdk-api/couchbase-ruby-client-3.1.0/index.html
+  source_code_uri: https://github.com/couchbase/couchbase-ruby-client/tree/3.1.1
+  changelog_uri: https://github.com/couchbase/couchbase-ruby-client/releases/tag/3.1.1
+  documentation_uri: https://docs.couchbase.com/sdk-api/couchbase-ruby-client-3.1.1/index.html
   github_repo: ssh://github.com/couchbase/couchbase-ruby-client
 post_install_message: 
 rdoc_options: