couchbase 3.1.1-universal-darwin-20 → 3.2.0-universal-darwin-20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ed2265468b3ab614f6e74a188015c2f96ce595116af1fc981ea30314e7d2ae3
-  data.tar.gz: bce8a86c7ea3f563e24b106dd981cace9bb558e9a6e70cb906e58df433b05201
+  metadata.gz: f6067d84b58a261969e5b43e9703dc036a4a612d2ce644e2247875d9fde089d7
+  data.tar.gz: 0a39070aa359284ee51490a9a79096b5ba14f6e0838f85373da6fc01b5ad7f34
 SHA512:
-  metadata.gz: 2a14b4867628eea0bb6a52c0eaf4e683b44261306b897f194de9f195c5aa2105ecb646c62c961ceeb903c7aa728342d130bfb15005bee07ecf9a3ebc8155c776
-  data.tar.gz: e31a897199cae23cd47c945f99353019cfa94e4a176a4a235de834143944b14b84aec84c5c0f99c12cce8a711155375e7525187d4c0b6b945ff1d5434750e44f
+  metadata.gz: 59818d9ce11ea0a643471fd4f4c58cd4e838f5dfd2e97fbd72640eea3469268582bf36162a74fcb92ebd8fdc681b92e1b3de3672c258d98fdb2f21dc971d614a
+  data.tar.gz: e9775a3b9b25b3670c874092aaa79734bfccff4475f2dee05a48334c8edffe5f40b86142a352c4e1f7ea9f34f6e211686d97dfd4b8faa8bfa5808122b26d680b

data/README.md

@@ -19,12 +19,12 @@ Please attach version information to ticket/post. To obtain this information use
 
 ## Installation
 
-The library tested with the MRI 2.5, 2.6, 2.7 and 3.0. Supported platforms are Linux and MacOS.
+The library tested with the MRI 2.6, 2.7 and 3.0. Supported platforms are Linux and MacOS.
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "couchbase", "3.1.1"
+gem "couchbase", "3.2.0"
 ```
 
 And then execute:

data/ext/CMakeLists.txt

@@ -71,7 +71,7 @@ add_library(
 target_include_directories(platform PRIVATE ${PROJECT_BINARY_DIR}/generated)
 target_link_libraries(platform PRIVATE ${PLATFORM_LIBRARIES})
 
-add_library(cbcrypto OBJECT couchbase/cbcrypto/cbcrypto.cc)
+add_library(cbcrypto OBJECT couchbase/cbcrypto/cbcrypto.cc couchbase/utils/name_codec.hxx)
 target_link_libraries(
   cbcrypto
   PRIVATE project_options
@@ -113,6 +113,7 @@ target_link_libraries(
           cbcrypto
           cbsasl
           http_parser
+          hdr_histogram_static
           snappy
           spdlog::spdlog_header_only)
 
@@ -121,6 +122,7 @@ set_target_properties(
   cbsasl
   platform
   snappy
+  hdr_histogram_static
   PROPERTIES POSITION_INDEPENDENT_CODE TRUE)
 
 if(APPLE)

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 = "a79d098eb238b3883e49e1738c35167642e8834f";
+constexpr auto BACKEND_GIT_REVISION = "6c069e4e6965117c7240b331847dc3f62afe0554";
 } // namespace couchbase

data/ext/cmake/Testing.cmake

@@ -40,6 +40,7 @@ if(ENABLE_TESTING)
       cbcrypto
       cbsasl
       http_parser
+      hdr_histogram_static
       snappy
       spdlog::spdlog_header_only)
     catch_discover_tests(test_native_${name})

data/ext/cmake/ThirdPartyDependencies.cmake

@@ -10,6 +10,12 @@ option(SNAPPY_BUILD_TESTS OFF)
 option(SNAPPY_INSTALL OFF)
 add_subdirectory(third_party/snappy)
 
+option(HDR_LOG_REQUIRED OFF)
+option(HDR_HISTOGRAM_BUILD_SHARED OFF)
+option(HDR_HISTOGRAM_BUILD_PROGRAMS OFF)
+add_subdirectory(third_party/hdr_histogram_c)
+include_directories(BEFORE SYSTEM third_party/hdr_histogram_c/src)
+
 include_directories(BEFORE SYSTEM third_party/gsl/include)
 include_directories(BEFORE SYSTEM third_party/asio/asio/include)
 include_directories(BEFORE SYSTEM third_party/json/include)

data/ext/cmake/VersionInfo.cmake

@@ -34,4 +34,7 @@ file(
 #define RUBY_INCLUDE_DIR \"${RUBY_INCLUDE_DIR}\"
 
 #define CMAKE_BUILD_TYPE \"${CMAKE_BUILD_TYPE}\"
+#define CMAKE_VERSION \"${CMAKE_VERSION}\"
+
+#define BACKEND_DEBUG_BUILD $<STREQUAL:$<UPPER_CASE:\"${CMAKE_BUILD_TYPE}\">,\"DEBUG\">
 ")

data/ext/couchbase/bucket.hxx

@@ -22,6 +22,8 @@
 
 #include <operations.hxx>
 #include <origin.hxx>
+#include <tracing/request_tracer.hxx>
+#include <metrics/meter.hxx>
 
 namespace couchbase
 {
@@ -31,6 +33,8 @@ class bucket : public std::enable_shared_from_this<bucket>
     explicit bucket(const std::string& client_id,
                     asio::io_context& ctx,
                     asio::ssl::context& tls,
+                    tracing::request_tracer* tracer,
+                    metrics::meter* meter,
                     std::string name,
                     couchbase::origin origin,
                     const std::vector<protocol::hello_feature>& known_features)
@@ -38,6 +42,8 @@ class bucket : public std::enable_shared_from_this<bucket>
       : client_id_(client_id)
       , ctx_(ctx)
       , tls_(tls)
+      , tracer_(tracer)
+      , meter_(meter)
       , name_(std::move(name))
       , origin_(std::move(origin))
       , known_features_(known_features)
@@ -80,7 +86,7 @@ class bucket : public std::enable_shared_from_this<bucket>
     {
         if (!config_) {
             spdlog::debug("{} initialize configuration rev={}", log_prefix_, config.rev_str());
-        } else if (config.rev && config_->rev && *config.rev > *config_->rev) {
+        } else if (config_ < config) {
             spdlog::debug("{} will update the configuration old={} -> new={}", log_prefix_, config_->rev_str(), config.rev_str());
         } else {
             return;
@@ -98,12 +104,13 @@ class bucket : public std::enable_shared_from_this<bucket>
         if (!added.empty() || removed.empty()) {
             std::map<size_t, std::shared_ptr<io::mcbp_session>> new_sessions{};
 
-            for (auto entry : sessions_) {
+            for (auto& [index, session] : sessions_) {
                 std::size_t new_index = config.nodes.size() + 1;
                 for (const auto& node : config.nodes) {
-                    if (entry.second->bootstrap_hostname() == node.hostname_for(origin_.options().network) &&
-                        entry.second->bootstrap_port() ==
-                          std::to_string(node.port_or(origin_.options().network, service_type::kv, origin_.options().enable_tls, 0))) {
+                    if (session->bootstrap_hostname() == node.hostname_for(origin_.options().network) &&
+                        session->bootstrap_port() ==
+                          std::to_string(
+                            node.port_or(origin_.options().network, service_type::key_value, origin_.options().enable_tls, 0))) {
                         new_index = node.index;
                         break;
                     }
@@ -112,18 +119,18 @@ class bucket : public std::enable_shared_from_this<bucket>
                     spdlog::debug(R"({} rev={}, preserve session="{}", address="{}:{}")",
                                   log_prefix_,
                                   config.rev_str(),
-                                  entry.second->id(),
-                                  entry.second->bootstrap_hostname(),
-                                  entry.second->bootstrap_port());
-                    new_sessions.emplace(new_index, std::move(entry.second));
+                                  session->id(),
+                                  session->bootstrap_hostname(),
+                                  session->bootstrap_port());
+                    new_sessions.emplace(new_index, std::move(session));
                 } else {
                     spdlog::debug(R"({} rev={}, drop session="{}", address="{}:{}")",
                                   log_prefix_,
                                   config.rev_str(),
-                                  entry.second->id(),
-                                  entry.second->bootstrap_hostname(),
-                                  entry.second->bootstrap_port());
-                    entry.second.reset();
+                                  session->id(),
+                                  session->bootstrap_hostname(),
+                                  session->bootstrap_port());
+                    session.reset();
                 }
             }
 
@@ -132,8 +139,8 @@ class bucket : public std::enable_shared_from_this<bucket>
                     continue;
                 }
 
-                auto hostname = node.hostname_for(origin_.options().network);
-                auto port = node.port_or(origin_.options().network, service_type::kv, origin_.options().enable_tls, 0);
+                const auto& hostname = node.hostname_for(origin_.options().network);
+                auto port = node.port_or(origin_.options().network, service_type::key_value, origin_.options().enable_tls, 0);
                 if (port == 0) {
                     continue;
                 }
@@ -172,7 +179,7 @@ class bucket : public std::enable_shared_from_this<bucket>
             spdlog::debug(R"({} requested to restart session idx={}, which does not exist, ignoring)", log_prefix_, index);
             return;
         }
-        auto& old_session = ptr->second;
+        const auto& old_session = ptr->second;
         auto hostname = old_session->bootstrap_hostname();
         auto port = old_session->bootstrap_port();
         auto old_id = old_session->id();
@@ -242,7 +249,7 @@ class bucket : public std::enable_shared_from_this<bucket>
         auto cmd = std::make_shared<operations::mcbp_command<bucket, Request>>(ctx_, shared_from_this(), request);
         cmd->start([cmd, handler = std::forward<Handler>(handler)](std::error_code ec, std::optional<io::mcbp_message> msg) mutable {
             using encoded_response_type = typename Request::encoded_response_type;
-            auto resp = msg ? encoded_response_type(*msg) : encoded_response_type{};
+            auto resp = msg ? encoded_response_type(std::move(*msg)) : encoded_response_type{};
             error_context::key_value ctx{};
             ctx.id = cmd->request.id;
             ctx.opaque = resp.opaque();
@@ -280,10 +287,10 @@ class bucket : public std::enable_shared_from_this<bucket>
         closed_ = true;
 
         drain_deferred_queue();
-        for (auto& session : sessions_) {
-            if (session.second) {
-                spdlog::debug(R"({} shutdown session session="{}", idx={})", log_prefix_, session.second->id(), session.first);
-                session.second->stop(io::retry_reason::do_not_retry);
+        for (auto& [index, session] : sessions_) {
+            if (session) {
+                spdlog::debug(R"({} shutdown session session="{}", idx={})", log_prefix_, session->id(), index);
+                session->stop(io::retry_reason::do_not_retry);
             }
         }
     }
@@ -305,13 +312,13 @@ class bucket : public std::enable_shared_from_this<bucket>
             std::tie(cmd->request.partition, index) = config_->map_key(cmd->request.id.key);
             if (index < 0) {
                 return io::retry_orchestrator::maybe_retry(
-                  cmd->manager_, cmd, io::retry_reason::node_not_available, std::make_error_code(error::common_errc::request_canceled));
+                  cmd->manager_, cmd, io::retry_reason::node_not_available, error::common_errc::request_canceled);
             }
         }
         auto session = sessions_.at(static_cast<std::size_t>(index));
         if (session->is_stopped()) {
             return io::retry_orchestrator::maybe_retry(
-              cmd->manager_, cmd, io::retry_reason::node_not_available, std::make_error_code(error::common_errc::request_canceled));
+              cmd->manager_, cmd, io::retry_reason::node_not_available, error::common_errc::request_canceled);
         }
         cmd->send_to(session);
     }
@@ -331,30 +338,42 @@ class bucket : public std::enable_shared_from_this<bucket>
         });
     }
 
-    [[nodiscard]] const std::string& log_prefix()
+    [[nodiscard]] const std::string& log_prefix() const
     {
         return log_prefix_;
     }
 
     void export_diag_info(diag::diagnostics_result& res) const
     {
-        for (const auto& session : sessions_) {
-            res.services[service_type::kv].emplace_back(session.second->diag_info());
+        for (const auto& [index, session] : sessions_) {
+            res.services[service_type::key_value].emplace_back(session->diag_info());
         }
     }
 
     template<typename Collector>
     void ping(std::shared_ptr<Collector> collector)
     {
-        for (const auto& session : sessions_) {
-            session.second->ping(collector->build_reporter());
+        for (const auto& [index, session] : sessions_) {
+            session->ping(collector->build_reporter());
         }
     }
 
+    auto tracer() const
+    {
+        return tracer_;
+    }
+
+    auto meter() const
+    {
+        return meter_;
+    }
+
   private:
     std::string client_id_;
     asio::io_context& ctx_;
     asio::ssl::context& tls_;
+    tracing::request_tracer* tracer_;
+    metrics::meter* meter_;
     std::string name_;
     origin origin_;
 

data/ext/couchbase/cbsasl/client.h

@@ -120,7 +120,7 @@ class ClientContext : public Context
         return backend->step(input);
     }
 
-  protected:
+  private:
     std::unique_ptr<MechanismBackend> backend;
 };
 

data/ext/couchbase/cbsasl/context.cc

@@ -21,7 +21,7 @@
 namespace couchbase::sasl
 {
 
-std::string
+const std::string&
 Context::get_uuid()
 {
     if (uuid.empty()) {

data/ext/couchbase/cbsasl/context.h

@@ -35,7 +35,7 @@ class Context
      * Get the UUID used for errors by this connection. If none
      * is created a new one is generated.
      */
-    std::string get_uuid();
+    [[nodiscard]] const std::string& get_uuid();
 
     /**
      * Do this context contain a UUID?
@@ -45,8 +45,8 @@ class Context
         return !uuid.empty();
     }
 
-  protected:
+  private:
     std::string uuid;
 };
 
-} // namespace couchbase::sasl
+} // namespace couchbase::sasl

data/ext/couchbase/cbsasl/mechanism.cc

@@ -21,9 +21,7 @@
 #include <iterator>
 #include <vector>
 
-namespace couchbase
-{
-namespace sasl
+namespace couchbase::sasl
 {
 
 Mechanism
@@ -35,14 +33,13 @@ select_mechanism(const std::vector<std::string>& available_mechanisms)
                                                                    { std::string{ "SCRAM-SHA1" }, Mechanism::SCRAM_SHA1 },
                                                                    { std::string{ "PLAIN" }, Mechanism::PLAIN } };
 
-    for (const auto& mechanism : mechs) {
-        if (std::find(available_mechanisms.begin(), available_mechanisms.end(), mechanism.first) != available_mechanisms.end()) {
-            return mechanism.second;
+    for (const auto& [name, code] : mechs) {
+        if (std::find(available_mechanisms.begin(), available_mechanisms.end(), name) != available_mechanisms.end()) {
+            return code;
         }
     }
 
     throw unknown_mechanism("unknown mechanism"); // TODO: avoid this exception
 }
 
-} // namespace sasl
-} // namespace couchbase
+} // namespace couchbase::sasl

data/ext/couchbase/cbsasl/mechanism.h

@@ -31,10 +31,7 @@ enum class Mechanism { SCRAM_SHA512, SCRAM_SHA256, SCRAM_SHA1, PLAIN };
 class unknown_mechanism : public std::invalid_argument
 {
   public:
-    explicit unknown_mechanism(const std::string& msg)
-      : std::invalid_argument(msg)
-    {
-    }
+    using std::invalid_argument::invalid_argument;
 };
 
 /**

data/ext/couchbase/cbsasl/plain/plain.cc

@@ -30,7 +30,7 @@ ClientBackend::start()
     buffer.push_back(0);
     std::copy(passwd.begin(), passwd.end(), std::back_inserter(buffer));
 
-    return std::make_pair<error, std::string_view>(error::OK, { buffer.data(), buffer.size() });
+    return { error::OK, { buffer.data(), buffer.size() } };
 }
 
 } // namespace couchbase::sasl::mechanism::plain

data/ext/couchbase/cbsasl/scram-sha/scram-sha.cc

@@ -27,11 +27,8 @@
 #include <cbsasl/scram-sha/stringutils.h>
 
 #include <cstring>
-#include <gsl/gsl>
-#include <iomanip>
 #include <iostream>
 #include <map>
-#include <memory>
 #include <set>
 #include <sstream>
 #include <string>
@@ -80,10 +77,10 @@ decodeAttributeList(const std::string& list, AttributeMap& attributes)
 
         auto comma = list.find(',', pos);
         if (comma == std::string::npos) {
-            attributes.insert(std::make_pair(key, list.substr(pos)));
+            attributes.try_emplace(key, list.substr(pos));
             pos = list.length();
         } else {
-            attributes.insert(std::make_pair(key, list.substr(pos, comma - pos)));
+            attributes.try_emplace(key, list.substr(pos, comma - pos));
             pos = comma + 1;
         }
     }
@@ -188,7 +185,6 @@ ScramShaBackend::addAttribute(std::ostream& out, char key, int value, bool more)
         case 'e': // error message
             throw std::invalid_argument("ScramShaBackend::addAttribute:"
                                         " Invalid value (should not be int)");
-            break;
 
         case 'i': // iterator count
             out << value;
@@ -284,14 +280,14 @@ ClientBackend::start()
     client_first_message = out.str();
     client_first_message_bare = client_first_message.substr(3); // skip n,,
 
-    return std::make_pair<error, std::string_view>(error::OK, client_first_message);
+    return { error::OK, client_first_message };
 }
 
 std::pair<error, std::string_view>
 ClientBackend::step(std::string_view input)
 {
     if (input.empty()) {
-        return std::make_pair<error, std::string_view>(error::BAD_PARAM, {});
+        return { error::BAD_PARAM, {} };
     }
 
     if (server_first_message.empty()) {
@@ -299,7 +295,7 @@ ClientBackend::step(std::string_view input)
 
         AttributeMap attributes;
         if (!decodeAttributeList(server_first_message, attributes)) {
-            return std::make_pair<error, std::string_view>(error::BAD_PARAM, {});
+            return { error::BAD_PARAM, {} };
         }
 
         for (const auto& attribute : attributes) {
@@ -314,24 +310,24 @@ ClientBackend::step(std::string_view input)
                     try {
                         iterationCount = static_cast<unsigned int>(std::stoul(attribute.second));
                     } catch (...) {
-                        return std::make_pair<error, std::string_view>(error::BAD_PARAM, {});
+                        return { error::BAD_PARAM, {} };
                     }
                     break;
                 default:
-                    return std::make_pair<error, std::string_view>(error::BAD_PARAM, {});
+                    return { error::BAD_PARAM, {} };
             }
         }
 
         if (attributes.find('r') == attributes.end() || attributes.find('s') == attributes.end() ||
             attributes.find('i') == attributes.end()) {
             spdlog::error("missing r/s/i in server message");
-            return std::make_pair<error, std::string_view>(error::BAD_PARAM, {});
+            return { error::BAD_PARAM, {} };
         }
 
         // I've got the SALT, lets generate the salted password
         if (!generateSaltedPassword(passwordCallback())) {
             spdlog::error("failed to generated salted password");
-            return std::make_pair<error, std::string_view>(error::FAIL, {});
+            return { error::FAIL, {} };
         }
 
         // Ok so we have salted hased password :D
@@ -346,34 +342,32 @@ ClientBackend::step(std::string_view input)
 
         client_final_message = out.str();
 
-        return std::make_pair<error, std::string_view>(error::CONTINUE, client_final_message);
-    } else {
-        server_final_message.assign(input.data(), input.size());
-
-        AttributeMap attributes;
-        if (!decodeAttributeList(server_final_message, attributes)) {
-            spdlog::error("SCRAM: failed to decode server-final-message");
-            return std::make_pair<error, std::string_view>(error::BAD_PARAM, {});
-        }
+        return { error::CONTINUE, client_final_message };
+    }
+    server_final_message.assign(input.data(), input.size());
 
-        if (attributes.find('e') != attributes.end()) {
-            spdlog::error("failed to authenticate: {}", attributes['e']);
-            return std::make_pair<error, std::string_view>(error::FAIL, {});
-        }
+    AttributeMap attributes;
+    if (!decodeAttributeList(server_final_message, attributes)) {
+        spdlog::error("SCRAM: failed to decode server-final-message");
+        return { error::BAD_PARAM, {} };
+    }
 
-        if (attributes.find('v') == attributes.end()) {
-            spdlog::error("syntax error server final message is missing 'v'");
-            return std::make_pair<error, std::string_view>(error::BAD_PARAM, {});
-        }
+    if (attributes.find('e') != attributes.end()) {
+        spdlog::error("failed to authenticate: {}", attributes['e']);
+        return { error::FAIL, {} };
+    }
 
-        auto encoded = couchbase::base64::encode(getServerSignature());
-        if (encoded != attributes['v']) {
-            spdlog::error("incorrect ServerKey received");
-            return std::make_pair<error, std::string_view>(error::FAIL, {});
-        }
+    if (attributes.find('v') == attributes.end()) {
+        spdlog::error("syntax error server final message is missing 'v'");
+        return { error::BAD_PARAM, {} };
+    }
 
-        return std::make_pair<error, std::string_view>(error::OK, {});
+    if (auto encoded = couchbase::base64::encode(getServerSignature()); encoded != attributes['v']) {
+        spdlog::error("incorrect ServerKey received");
+        return { error::FAIL, {} };
     }
+
+    return { error::OK, {} };
 }
 
 bool