couchbase 3.1.1 → 3.2.0

data/ext/couchbase/error_map.hxx

@@ -120,7 +120,7 @@ struct error_map {
         std::string description;
         std::set<attribute> attributes;
 
-        bool has_retry_attribute()
+        bool has_retry_attribute() const
         {
             return attributes.find(attribute::retry_now) != attributes.end() || attributes.find(attribute::retry_later) != attributes.end();
         }

data/ext/couchbase/errors.hxx

@@ -244,6 +244,9 @@ enum class analytics_errc {
 
     /// Raised When 24006
     link_not_found,
+
+    /// Raised When 24055
+    link_exists,
 };
 
 /// Errors related to Search service (CBFT)
@@ -313,12 +316,12 @@ namespace detail
 struct common_error_category : std::error_category {
     [[nodiscard]] const char* name() const noexcept override
     {
-        return "common";
+        return "couchbase.common";
     }
 
     [[nodiscard]] std::string message(int ev) const noexcept override
     {
-        switch (static_cast<common_errc>(ev)) {
+        switch (common_errc(ev)) {
             case common_errc::unambiguous_timeout:
                 return "unambiguous_timeout";
             case common_errc::ambiguous_timeout:
@@ -372,12 +375,12 @@ get_common_category()
 struct key_value_error_category : std::error_category {
     [[nodiscard]] const char* name() const noexcept override
     {
-        return "key_value";
+        return "couchbase.key_value";
     }
 
     [[nodiscard]] std::string message(int ev) const noexcept override
     {
-        switch (static_cast<key_value_errc>(ev)) {
+        switch (key_value_errc(ev)) {
             case key_value_errc::document_not_found:
                 return "document_not_found";
             case key_value_errc::document_irretrievable:
@@ -442,12 +445,12 @@ get_key_value_category()
 struct query_error_category : std::error_category {
     [[nodiscard]] const char* name() const noexcept override
     {
-        return "query";
+        return "couchbase.query";
     }
 
     [[nodiscard]] std::string message(int ev) const noexcept override
     {
-        switch (static_cast<query_errc>(ev)) {
+        switch (query_errc(ev)) {
             case query_errc::planning_failure:
                 return "planning_failure";
             case query_errc::index_failure:
@@ -469,12 +472,12 @@ get_query_category()
 struct search_error_category : std::error_category {
     [[nodiscard]] const char* name() const noexcept override
     {
-        return "search";
+        return "couchbase.search";
     }
 
     [[nodiscard]] std::string message(int ev) const noexcept override
     {
-        switch (static_cast<search_errc>(ev)) {
+        switch (search_errc(ev)) {
             case search_errc::index_not_ready:
                 return "index_not_ready";
             case search_errc::consistency_mismatch:
@@ -494,12 +497,12 @@ get_search_category()
 struct view_error_category : std::error_category {
     [[nodiscard]] const char* name() const noexcept override
     {
-        return "view";
+        return "couchbase.view";
     }
 
     [[nodiscard]] std::string message(int ev) const noexcept override
     {
-        switch (static_cast<view_errc>(ev)) {
+        switch (view_errc(ev)) {
             case view_errc::view_not_found:
                 return "view_not_found";
             case view_errc::design_document_not_found:
@@ -519,12 +522,12 @@ get_view_category()
 struct analytics_error_category : std::error_category {
     [[nodiscard]] const char* name() const noexcept override
     {
-        return "analytics";
+        return "couchbase.analytics";
     }
 
     [[nodiscard]] std::string message(int ev) const noexcept override
     {
-        switch (static_cast<analytics_errc>(ev)) {
+        switch (analytics_errc(ev)) {
             case analytics_errc::compilation_failure:
                 return "compilation_failure";
             case analytics_errc::job_queue_full:
@@ -539,6 +542,8 @@ struct analytics_error_category : std::error_category {
                 return "dataverse_exists";
             case analytics_errc::link_not_found:
                 return "link_not_found";
+            case analytics_errc::link_exists:
+                return "link_exists";
         }
         return "FIXME: unknown error code in analytics category (recompile with newer library)";
     }
@@ -554,12 +559,12 @@ get_analytics_category()
 struct management_error_category : std::error_category {
     [[nodiscard]] const char* name() const noexcept override
     {
-        return "management";
+        return "couchbase.management";
     }
 
     [[nodiscard]] std::string message(int ev) const noexcept override
     {
-        switch (static_cast<management_errc>(ev)) {
+        switch (management_errc(ev)) {
             case management_errc::collection_exists:
                 return "collection_exists";
             case management_errc::scope_exists:
@@ -589,12 +594,12 @@ get_management_category()
 struct network_error_category : std::error_category {
     [[nodiscard]] const char* name() const noexcept override
     {
-        return "network";
+        return "couchbase.network";
     }
 
     [[nodiscard]] std::string message(int ev) const noexcept override
     {
-        switch (static_cast<network_errc>(ev)) {
+        switch (network_errc(ev)) {
             case network_errc::resolve_failure:
                 return "resolve_failure";
             case network_errc::no_endpoints_left:
@@ -654,7 +659,10 @@ struct is_error_code_enum<couchbase::error::management_errc> : true_type {
 template<>
 struct is_error_code_enum<couchbase::error::network_errc> : true_type {
 };
+} // namespace std
 
+namespace couchbase::error
+{
 inline std::error_code
 make_error_code(couchbase::error::common_errc e)
 {
@@ -703,4 +711,4 @@ make_error_code(couchbase::error::network_errc e)
     return { static_cast<int>(e), couchbase::error::detail::get_network_category() };
 }
 
-} // namespace std
+} // namespace couchbase::error

data/ext/couchbase/io/dns_client.hxx

@@ -81,7 +81,7 @@ class dns_client
                                                                                     std::size_t /* bytes_transferred */) mutable {
                   if (ec1 == asio::error::operation_aborted) {
                       self->deadline_.cancel();
-                      return handler({ std::make_error_code(error::common_errc::unambiguous_timeout) });
+                      return handler({ error::common_errc::unambiguous_timeout });
                   }
                   if (ec1) {
                       self->deadline_.cancel();
@@ -148,7 +148,7 @@ class dns_client
                         if (ec2) {
                             self->deadline_.cancel();
                             if (ec2 == asio::error::operation_aborted) {
-                                ec2 = std::make_error_code(error::common_errc::unambiguous_timeout);
+                                ec2 = error::common_errc::unambiguous_timeout;
                             }
                             return handler({ ec2 });
                         }
@@ -207,7 +207,7 @@ class dns_client
     template<class Handler>
     void query_srv(const std::string& name, const std::string& service, Handler&& handler)
     {
-        dns_config& config = dns_config::get();
+        const dns_config& config = dns_config::get();
         auto cmd = std::make_shared<dns_srv_command>(ctx_, name, service, config.address(), config.port());
         cmd->execute(config.timeout(), std::forward<Handler>(handler));
     }

data/ext/couchbase/io/dns_codec.hxx

@@ -65,7 +65,7 @@ class dns_codec
             std::memcpy(&val, payload.data() + offset, sizeof(std::uint16_t));
             offset += sizeof(std::uint16_t);
             val = ntohs(val);
-            qr.type = static_cast<resource_type>(val);
+            qr.type = resource_type(val);
 
             std::memcpy(&val, payload.data() + offset, sizeof(std::uint16_t));
             offset += sizeof(std::uint16_t);
@@ -84,12 +84,12 @@ class dns_codec
             std::memcpy(&val, payload.data() + offset, sizeof(std::uint16_t));
             offset += sizeof(std::uint16_t);
             val = ntohs(val);
-            ar.type = static_cast<resource_type>(val);
+            ar.type = resource_type(val);
 
             std::memcpy(&val, payload.data() + offset, sizeof(std::uint16_t));
             offset += sizeof(std::uint16_t);
             val = ntohs(val);
-            ar.klass = static_cast<resource_class>(val);
+            ar.klass = resource_class(val);
 
             std::memcpy(&ar.ttl, payload.data() + offset, sizeof(std::uint32_t));
             offset += static_cast<std::uint16_t>(4U);
@@ -196,8 +196,7 @@ class dns_codec
                 save_offset = offset + sizeof(std::uint16_t);
                 offset = ptr;
             } else {
-                std::string label(payload.data() + offset + 1, payload.data() + offset + 1 + len);
-                name.labels.emplace_back(label);
+                name.labels.emplace_back(payload.data() + offset + 1, payload.data() + offset + 1 + len);
                 offset += static_cast<std::uint16_t>(1U + len);
             }
         }

data/ext/couchbase/io/dns_config.hxx

@@ -19,8 +19,8 @@
 
 #include <unistd.h>
 
-#include <string>
 #include <fstream>
+#include <string>
 
 #include <asio/ip/address.hpp>
 
@@ -31,9 +31,9 @@ namespace couchbase::io::dns
 class dns_config
 {
   public:
-    static inline constexpr auto default_resolv_conf_path = "/etc/resolv.conf";
-    static inline constexpr auto default_host = "8.8.8.8";
-    static inline constexpr std::uint16_t default_port = 53;
+    static constexpr auto default_resolv_conf_path = "/etc/resolv.conf";
+    static constexpr auto default_host = "8.8.8.8";
+    static constexpr std::uint16_t default_port = 53;
 
     [[nodiscard]] const asio::ip::address& address() const
     {
@@ -95,8 +95,7 @@ class dns_config
                 if (space == std::string::npos || space == offset || line.size() < space + 2) {
                     continue;
                 }
-                std::string keyword = line.substr(offset, space);
-                if (keyword != "nameserver") {
+                if (std::string keyword = line.substr(offset, space); keyword != "nameserver") {
                     continue;
                 }
                 offset = space + 1;

data/ext/couchbase/io/dns_message.hxx

@@ -321,15 +321,15 @@ struct dns_header {
 
         void decode(std::uint16_t blob)
         {
-            qr = static_cast<message_type>((static_cast<std::uint32_t>(blob) >> 15U) & 1U);
-            opcode = static_cast<dns::opcode>((static_cast<std::uint32_t>(blob) >> 11U) & 15U);
+            qr = message_type((static_cast<std::uint32_t>(blob) >> 15U) & 1U);
+            opcode = dns::opcode((static_cast<std::uint32_t>(blob) >> 11U) & 15U);
 
             aa = ((static_cast<std::uint32_t>(blob) >> 10U) & 1U) != 0U ? authoritative_answer::yes : authoritative_answer::no;
             tc = ((static_cast<std::uint32_t>(blob) >> 9U) & 1U) != 0U ? truncation::yes : truncation::no;
             rd = ((static_cast<std::uint32_t>(blob) >> 8U) & 1U) != 0U ? recursion_desired::yes : recursion_desired::no;
             ra = ((static_cast<std::uint32_t>(blob) >> 7U) & 1U) != 0U ? recursion_available::yes : recursion_available::no;
 
-            rcode = static_cast<response_code>(blob & 15U);
+            rcode = response_code(blob & 15U);
         }
     };
 

data/ext/couchbase/io/http_command.hxx

@@ -19,6 +19,9 @@
 
 #include <io/http_session.hxx>
 
+#include <tracing/request_tracer.hxx>
+#include <metrics/meter.hxx>
+
 namespace couchbase::operations
 {
 
@@ -31,22 +34,37 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
     asio::steady_timer retry_backoff;
     Request request;
     encoded_request_type encoded;
+    tracing::request_tracer* tracer_;
+    tracing::request_span* span_{ nullptr };
+    metrics::meter* meter_;
 
-    http_command(asio::io_context& ctx, Request req)
+    http_command(asio::io_context& ctx, Request req, tracing::request_tracer* tracer, metrics::meter* meter)
       : deadline(ctx)
       , retry_backoff(ctx)
       , request(req)
+      , tracer_(tracer)
+      , meter_(meter)
+    {
+    }
+
+    void finish_dispatch(const std::string& remote_address, const std::string& local_address)
     {
+        if (span_ == nullptr) {
+            return;
+        }
+        span_->add_tag(tracing::attributes::remote_socket, remote_address);
+        span_->add_tag(tracing::attributes::local_socket, local_address);
+        span_->end();
+        span_ = nullptr;
     }
 
     template<typename Handler>
     void send_to(std::shared_ptr<io::http_session> session, Handler&& handler)
     {
         encoded.type = request.type;
-        auto encoding_ec = request.encode_to(encoded, session->http_context());
-        if (encoding_ec) {
+        if (auto ec = request.encode_to(encoded, session->http_context()); ec) {
             error_context_type ctx{};
-            ctx.ec = encoding_ec;
+            ctx.ec = ec;
             ctx.client_context_id = request.client_context_id;
             return handler(make_response(std::move(ctx), request, {}));
         }
@@ -67,37 +85,54 @@ struct http_command : public std::enable_shared_from_this<http_command<Request>>
                      request.client_context_id,
                      request.timeout.count(),
                      spdlog::to_hex(encoded.body));
-        session->write_and_subscribe(encoded,
-                                     [self = this->shared_from_this(), log_prefix, session, handler = std::forward<Handler>(handler)](
-                                       std::error_code ec, io::http_response&& msg) mutable {
-                                         self->deadline.cancel();
-                                         encoded_response_type resp(msg);
-                                         spdlog::trace(R"({} HTTP response: {}, client_context_id="{}", status={})",
-                                                       log_prefix,
-                                                       self->request.type,
-                                                       self->request.client_context_id,
-                                                       resp.status_code);
-                                         SPDLOG_TRACE(R"({} HTTP response: {}, client_context_id="{}", status={}{:a})",
-                                                      log_prefix,
-                                                      self->request.type,
-                                                      self->request.client_context_id,
-                                                      resp.status_code,
-                                                      spdlog::to_hex(resp.body));
-                                         try {
-                                             error_context_type ctx{};
-                                             ctx.ec = ec;
-                                             ctx.client_context_id = self->request.client_context_id;
-                                             ctx.method = self->encoded.method;
-                                             ctx.path = self->encoded.path;
-                                             ctx.last_dispatched_from = session->local_address();
-                                             ctx.last_dispatched_to = session->remote_address();
-                                             ctx.http_status = msg.status_code;
-                                             ctx.http_body = msg.body;
-                                             handler(make_response(std::move(ctx), self->request, std::move(msg)));
-                                         } catch (priv::retry_http_request&) {
-                                             self->send_to(session, std::forward<Handler>(handler));
-                                         }
-                                     });
+        span_ = tracer_->start_span(tracing::span_name_for_http_service(request.type), nullptr);
+        span_->add_tag(tracing::attributes::service, tracing::service_name_for_http_service(request.type));
+        span_->add_tag(tracing::attributes::operation_id, request.client_context_id);
+        span_->add_tag(tracing::attributes::local_id, session->id());
+        session->write_and_subscribe(
+          encoded,
+          [self = this->shared_from_this(),
+           log_prefix,
+           session,
+           handler = std::forward<Handler>(handler),
+           start = std::chrono::steady_clock::now()](std::error_code ec, io::http_response&& msg) mutable {
+              static std::string meter_name = "db.couchbase.operations";
+              static std::map<std::string, std::string> tags = {
+                  { "db.couchbase.service", fmt::format("{}", self->request.type) },
+                  { "db.operation", self->encoded.path },
+              };
+              self->meter_->get_value_recorder(meter_name, tags)
+                ->record_value(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - start).count());
+
+              self->deadline.cancel();
+              self->finish_dispatch(session->remote_address(), session->local_address());
+              encoded_response_type resp(msg);
+              spdlog::trace(R"({} HTTP response: {}, client_context_id="{}", status={})",
+                            log_prefix,
+                            self->request.type,
+                            self->request.client_context_id,
+                            resp.status_code);
+              SPDLOG_TRACE(R"({} HTTP response: {}, client_context_id="{}", status={}{:a})",
+                           log_prefix,
+                           self->request.type,
+                           self->request.client_context_id,
+                           resp.status_code,
+                           spdlog::to_hex(resp.body));
+              try {
+                  error_context_type ctx{};
+                  ctx.ec = ec;
+                  ctx.client_context_id = self->request.client_context_id;
+                  ctx.method = self->encoded.method;
+                  ctx.path = self->encoded.path;
+                  ctx.last_dispatched_from = session->local_address();
+                  ctx.last_dispatched_to = session->remote_address();
+                  ctx.http_status = msg.status_code;
+                  ctx.http_body = msg.body;
+                  handler(make_response(std::move(ctx), self->request, std::move(msg)));
+              } catch (const priv::retry_http_request&) {
+                  self->send_to(session, std::forward<Handler>(handler));
+              }
+          });
         deadline.expires_after(request.timeout);
         deadline.async_wait([session](std::error_code ec) {
             if (ec == asio::error::operation_aborted) {

data/ext/couchbase/io/http_session.hxx

@@ -172,7 +172,7 @@ class http_session : public std::enable_shared_from_this<http_session>
         {
             std::scoped_lock lock(command_handlers_mutex_);
             for (auto& handler : command_handlers_) {
-                handler(std::make_error_code(error::common_errc::ambiguous_timeout), {});
+                handler(error::common_errc::ambiguous_timeout, {});
             }
             command_handlers_.clear();
         }
@@ -202,7 +202,7 @@ class http_session : public std::enable_shared_from_this<http_session>
         output_buffer_.push_back(buf);
     }
 
-    void write(const std::string& buf)
+    void write(const std::string_view& buf)
     {
         if (stopped_) {
             return;
@@ -221,7 +221,8 @@ class http_session : public std::enable_shared_from_this<http_session>
         do_write();
     }
 
-    void write_and_subscribe(io::http_request& request, std::function<void(std::error_code, io::http_response&&)>&& handler)
+    template<typename Handler>
+    void write_and_subscribe(io::http_request& request, Handler&& handler)
     {
         if (stopped_) {
             return;

data/ext/couchbase/io/http_session_manager.hxx

@@ -23,6 +23,9 @@
 #include <operations/http_noop.hxx>
 #include <io/http_command.hxx>
 
+#include <tracing/noop_tracer.hxx>
+#include <metrics/meter.hxx>
+
 #include <random>
 
 namespace couchbase::io
@@ -38,6 +41,16 @@ class http_session_manager : public std::enable_shared_from_this<http_session_ma
     {
     }
 
+    void set_tracer(tracing::request_tracer* tracer)
+    {
+        tracer_ = tracer;
+    }
+
+    void set_meter(metrics::meter* meter)
+    {
+        meter_ = meter;
+    }
+
     void set_configuration(const configuration& config, const cluster_options& options)
     {
         options_ = options;
@@ -74,7 +87,7 @@ class http_session_manager : public std::enable_shared_from_this<http_session_ma
     template<typename Collector>
     void ping(std::set<service_type> services, std::shared_ptr<Collector> collector, const couchbase::cluster_credentials& credentials)
     {
-        std::array<service_type, 4> known_types{ service_type::query, service_type::analytics, service_type::search, service_type::views };
+        std::array<service_type, 4> known_types{ service_type::query, service_type::analytics, service_type::search, service_type::view };
         for (auto& node : config_.nodes) {
             for (auto type : known_types) {
                 if (services.find(type) == services.end()) {
@@ -116,7 +129,7 @@ class http_session_manager : public std::enable_shared_from_this<http_session_ma
                     busy_sessions_[type].push_back(session);
                     operations::http_noop_request request{};
                     request.type = type;
-                    auto cmd = std::make_shared<operations::http_command<operations::http_noop_request>>(ctx_, request);
+                    auto cmd = std::make_shared<operations::http_command<operations::http_noop_request>>(ctx_, request, tracer_, meter_);
                     cmd->send_to(
                       session,
                       [start = std::chrono::steady_clock::now(),
@@ -153,9 +166,7 @@ class http_session_manager : public std::enable_shared_from_this<http_session_ma
         idle_sessions_[type].remove_if([](const auto& s) -> bool { return !s; });
         busy_sessions_[type].remove_if([](const auto& s) -> bool { return !s; });
         if (idle_sessions_[type].empty()) {
-            std::string hostname;
-            std::uint16_t port = 0;
-            std::tie(hostname, port) = next_node(type);
+            auto [hostname, port] = next_node(type);
             if (port == 0) {
                 return nullptr;
             }
@@ -214,21 +225,17 @@ class http_session_manager : public std::enable_shared_from_this<http_session_ma
 
     void close()
     {
-        {
-            for (auto& sessions : idle_sessions_) {
-                for (auto& s : sessions.second) {
-                    if (s) {
-                        s->reset_idle();
-                        s.reset();
-                    }
+        for (auto& sessions : idle_sessions_) {
+            for (auto& s : sessions.second) {
+                if (s) {
+                    s->reset_idle();
+                    s.reset();
                 }
             }
         }
-        {
-            for (auto& sessions : busy_sessions_) {
-                for (auto& s : sessions.second) {
-                    s.reset();
-                }
+        for (auto& sessions : busy_sessions_) {
+            for (auto& s : sessions.second) {
+                s.reset();
             }
         }
     }
@@ -239,7 +246,7 @@ class http_session_manager : public std::enable_shared_from_this<http_session_ma
         auto candidates = config_.nodes.size();
         while (candidates > 0) {
             --candidates;
-            auto& node = config_.nodes[next_index_];
+            const auto& node = config_.nodes[next_index_];
             next_index_ = (next_index_ + 1) % config_.nodes.size();
             std::uint16_t port = node.port_or(options_.network, type, options_.enable_tls, 0);
             if (port != 0) {
@@ -252,7 +259,9 @@ class http_session_manager : public std::enable_shared_from_this<http_session_ma
     std::string client_id_;
     asio::io_context& ctx_;
     asio::ssl::context& tls_;
-    cluster_options options_;
+    tracing::request_tracer* tracer_{ nullptr };
+    metrics::meter* meter_{ nullptr };
+    cluster_options options_{};
 
     configuration config_{};
     std::map<service_type, std::list<std::shared_ptr<http_session>>> busy_sessions_{};