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

data/ext/couchbase/protocol/server_request.hxx

@@ -96,7 +96,7 @@ class server_request
     {
         Expects(header_[0] == static_cast<std::uint8_t>(magic_));
         Expects(header_[1] == static_cast<std::uint8_t>(Body::opcode));
-        opcode_ = static_cast<server_opcode>(header_[1]);
+        opcode_ = server_opcode(header_[1]);
         data_type_ = header_[5];
 
         uint32_t field = 0;

data/ext/couchbase/protocol/status.hxx

@@ -17,9 +17,7 @@
 
 #pragma once
 
-namespace couchbase
-{
-namespace protocol
+namespace couchbase::protocol
 {
 enum class status : uint16_t {
     success = 0x00,
@@ -81,10 +79,10 @@ enum class status : uint16_t {
     subdoc_invalid_xattr_order = 0xd4,
 };
 
-constexpr inline bool
+constexpr bool
 is_valid_status(uint16_t code)
 {
-    switch (static_cast<status>(code)) {
+    switch (status(code)) {
         case status::success:
         case status::not_found:
         case status::exists:
@@ -156,8 +154,7 @@ status_to_string(uint16_t code)
     return fmt::format("{} (unknown)", code);
 }
 
-} // namespace protocol
-} // namespace couchbase
+} // namespace couchbase::protocol
 
 template<>
 struct fmt::formatter<couchbase::protocol::status> : formatter<string_view> {

data/ext/couchbase/protocol/unsigned_leb128.h

@@ -46,8 +46,8 @@ struct Leb128NoThrow {
  *          leb128 data.
  */
 template<class T>
-typename std::enable_if<std::is_unsigned<T>::value, std::pair<T, std::string_view>>::type
-decode_unsigned_leb128(std::string_view buf, struct Leb128NoThrow)
+typename std::enable_if_t<std::is_unsigned_v<T>, std::pair<T, std::string_view>>
+decode_unsigned_leb128(std::string_view buf, struct Leb128NoThrow /* unused */)
 {
     T rv = static_cast<uint8_t>(buf[0]) & 0x7fULL;
     size_t end = 0;
@@ -83,7 +83,7 @@ decode_unsigned_leb128(std::string_view buf, struct Leb128NoThrow)
  *         a stop byte.
  */
 template<class T>
-typename std::enable_if<std::is_unsigned<T>::value, std::pair<T, std::string_view>>::type
+typename std::enable_if_t<std::is_unsigned_v<T>, std::pair<T, std::string_view>>
 decode_unsigned_leb128(std::string_view buf)
 {
     if (buf.size() > 0) {
@@ -99,27 +99,12 @@ decode_unsigned_leb128(std::string_view buf)
  * @return a buffer to the data after the leb128 prefix
  */
 template<class T>
-typename std::enable_if<std::is_unsigned<T>::value, std::string_view>::type
+typename std::enable_if_t<std::is_unsigned_v<T>, std::string_view>
 skip_unsigned_leb128(std::string_view buf)
 {
     return decode_unsigned_leb128<T>(buf).second;
 }
 
-/// @return the index of the stop byte within buf
-static inline std::optional<size_t>
-unsigned_leb128_get_stop_byte_index(std::string_view buf)
-{
-    // If buf does not contain a stop-byte, invalid
-    size_t stopByte = 0;
-    for (auto c : buf) {
-        if ((static_cast<uint8_t>(c) & 0x80ULL) == 0) {
-            return stopByte;
-        }
-        stopByte++;
-    }
-    return {};
-}
-
 // Empty, non specialised version of the decoder class
 template<class T, class Enable = void>
 class unsigned_leb128
@@ -131,7 +116,7 @@ class unsigned_leb128
  * provides a const_byte_buffer for access to the encoded
  */
 template<class T>
-class unsigned_leb128<T, typename std::enable_if<std::is_unsigned<T>::value>::type>
+class unsigned_leb128<T, typename std::enable_if_t<std::is_unsigned_v<T>>>
 {
   public:
     explicit unsigned_leb128(T in)

data/ext/couchbase/service_type.hxx

@@ -20,11 +20,11 @@
 namespace couchbase
 {
 enum class service_type {
-    kv,
+    key_value = 0,
     query,
     analytics,
     search,
-    views,
+    view,
     management,
 };
 } // namespace couchbase
@@ -36,7 +36,7 @@ struct fmt::formatter<couchbase::service_type> : formatter<std::string_view> {
     {
         string_view name = "unknown";
         switch (type) {
-            case couchbase::service_type::kv:
+            case couchbase::service_type::key_value:
                 name = "kv";
                 break;
             case couchbase::service_type::query:
@@ -48,7 +48,7 @@ struct fmt::formatter<couchbase::service_type> : formatter<std::string_view> {
             case couchbase::service_type::search:
                 name = "search";
                 break;
-            case couchbase::service_type::views:
+            case couchbase::service_type::view:
                 name = "views";
                 break;
             case couchbase::service_type::management:

data/ext/couchbase/tracing/constants.hxx

@@ -0,0 +1,261 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <string_view>
+
+#include <protocol/client_opcode.hxx>
+#include <service_type.hxx>
+
+namespace couchbase::tracing
+{
+namespace operation
+{
+constexpr auto step_dispatch = "cb.dispatch_to_server";
+constexpr auto step_request_encoding = "cb.request_encoding";
+constexpr auto http_query = "cb.query";
+constexpr auto http_analytics = "cb.analytics";
+constexpr auto http_search = "cb.search";
+constexpr auto http_views = "cb.views";
+constexpr auto http_manager = "cb.manager";
+constexpr auto http_manager_analytics = "cb.manager_analytics";
+constexpr auto http_manager_query = "cb.manager_query";
+constexpr auto http_manager_buckets = "cb.manager_buckets";
+constexpr auto http_manager_collections = "cb.manager_collections";
+constexpr auto http_manager_search = "cb.manager_search";
+constexpr auto http_manager_users = "cb.manager_users";
+constexpr auto http_manager_views = "cb.manager_views";
+constexpr auto mcbp_get = "cb.get";
+constexpr auto mcbp_get_replica = "cb.get_replica";
+constexpr auto mcbp_upsert = "cb.upsert";
+constexpr auto mcbp_replace = "cb.replace";
+constexpr auto mcbp_insert = "cb.insert";
+constexpr auto mcbp_remove = "cb.remove";
+constexpr auto mcbp_get_and_lock = "cb.get_and_lock";
+constexpr auto mcbp_get_and_touch = "cb.get_and_touch";
+constexpr auto mcbp_exists = "cb.exists";
+constexpr auto mcbp_touch = "cb.touch";
+constexpr auto mcbp_unlock = "cb.unlock";
+constexpr auto mcbp_lookup_in = "cb.lookup_in";
+constexpr auto mcbp_mutate_in = "cb.mutate_in";
+constexpr auto mcbp_append = "cb.append";
+constexpr auto mcbp_prepend = "cb.prepend";
+constexpr auto mcbp_increment = "cb.increment";
+constexpr auto mcbp_decrement = "cb.decrement";
+constexpr auto mcbp_observe = "cb.observe";
+/* multi-command operations */
+constexpr auto mcbp_get_all_replicas = "cb.get_all_replicas";
+constexpr auto mcbp_get_any_replica = "cb.get_any_replica";
+constexpr auto mcbp_list = "cb.list";
+constexpr auto mcbp_set = "cb.set";
+constexpr auto mcbp_map = "cb.map";
+constexpr auto mcbp_queue = "cb.queue";
+constexpr auto mcbp_ping = "cb.ping";
+} // namespace operation
+
+namespace attributes
+{
+constexpr auto system = "db.system";
+constexpr auto span_kind = "span.kind";
+constexpr auto component = "db.couchbase.component";
+constexpr auto instance = "db.instance";
+
+constexpr auto orphan = "cb.orphan";
+constexpr auto service = "cb.service";
+constexpr auto operation_id = "cb.operation_id";
+
+constexpr auto server_duration = "cb.server_duration";
+constexpr auto local_id = "cb.local_id";
+constexpr auto local_socket = "cb.local_socket";
+constexpr auto remote_socket = "cb.remote_socket";
+} // namespace attributes
+
+namespace service
+{
+constexpr auto key_value = "kv";
+constexpr auto query = "query";
+constexpr auto search = "search";
+constexpr auto view = "views";
+constexpr auto analytics = "analytics";
+constexpr auto management = "management";
+} // namespace service
+
+auto
+span_name_for_http_service(service_type type)
+{
+    switch (type) {
+        case service_type::query:
+            return operation::http_query;
+
+        case service_type::analytics:
+            return operation::http_analytics;
+
+        case service_type::search:
+            return operation::http_search;
+
+        case service_type::view:
+            return operation::http_views;
+
+        case service_type::management:
+            return operation::http_manager;
+
+        case service_type::key_value:
+            Expects(false);
+    }
+    Expects(false);
+}
+
+auto
+service_name_for_http_service(service_type type)
+{
+    switch (type) {
+        case service_type::query:
+            return service::query;
+
+        case service_type::analytics:
+            return service::analytics;
+
+        case service_type::search:
+            return service::search;
+
+        case service_type::view:
+            return service::view;
+
+        case service_type::management:
+            return service::management;
+
+        case service_type::key_value:
+            Expects(false);
+    }
+    Expects(false);
+}
+
+auto
+span_name_for_mcbp_command(protocol::client_opcode opcode)
+{
+    switch (opcode) {
+        case protocol::client_opcode::get:
+            return operation::mcbp_get;
+
+        case protocol::client_opcode::upsert:
+            return operation::mcbp_upsert;
+
+        case protocol::client_opcode::insert:
+            return operation::mcbp_insert;
+
+        case protocol::client_opcode::replace:
+            return operation::mcbp_replace;
+
+        case protocol::client_opcode::remove:
+            return operation::mcbp_remove;
+
+        case protocol::client_opcode::increment:
+            return operation::mcbp_increment;
+
+        case protocol::client_opcode::decrement:
+            return operation::mcbp_decrement;
+
+        case protocol::client_opcode::append:
+            return operation::mcbp_append;
+
+        case protocol::client_opcode::prepend:
+            return operation::mcbp_prepend;
+
+        case protocol::client_opcode::touch:
+            return operation::mcbp_touch;
+
+        case protocol::client_opcode::get_and_touch:
+            return operation::mcbp_get_and_touch;
+
+        case protocol::client_opcode::get_replica:
+            return operation::mcbp_get_replica;
+
+        case protocol::client_opcode::get_and_lock:
+            return operation::mcbp_get_and_lock;
+
+        case protocol::client_opcode::unlock:
+            return operation::mcbp_unlock;
+
+        case protocol::client_opcode::subdoc_multi_lookup:
+            return operation::mcbp_lookup_in;
+
+        case protocol::client_opcode::subdoc_multi_mutation:
+            return operation::mcbp_mutate_in;
+
+        case protocol::client_opcode::observe:
+            return operation::mcbp_exists;
+
+        case protocol::client_opcode::noop:
+        case protocol::client_opcode::version:
+        case protocol::client_opcode::stat:
+        case protocol::client_opcode::verbosity:
+        case protocol::client_opcode::hello:
+        case protocol::client_opcode::sasl_list_mechs:
+        case protocol::client_opcode::sasl_auth:
+        case protocol::client_opcode::sasl_step:
+        case protocol::client_opcode::get_all_vbucket_seqnos:
+        case protocol::client_opcode::dcp_open:
+        case protocol::client_opcode::dcp_add_stream:
+        case protocol::client_opcode::dcp_close_stream:
+        case protocol::client_opcode::dcp_stream_request:
+        case protocol::client_opcode::dcp_get_failover_log:
+        case protocol::client_opcode::dcp_stream_end:
+        case protocol::client_opcode::dcp_snapshot_marker:
+        case protocol::client_opcode::dcp_mutation:
+        case protocol::client_opcode::dcp_deletion:
+        case protocol::client_opcode::dcp_expiration:
+        case protocol::client_opcode::dcp_set_vbucket_state:
+        case protocol::client_opcode::dcp_noop:
+        case protocol::client_opcode::dcp_buffer_acknowledgement:
+        case protocol::client_opcode::dcp_control:
+        case protocol::client_opcode::dcp_system_event:
+        case protocol::client_opcode::dcp_prepare:
+        case protocol::client_opcode::dcp_seqno_acknowledged:
+        case protocol::client_opcode::dcp_commit:
+        case protocol::client_opcode::dcp_abort:
+        case protocol::client_opcode::dcp_seqno_advanced:
+        case protocol::client_opcode::dcp_oso_snapshot:
+        case protocol::client_opcode::list_buckets:
+        case protocol::client_opcode::select_bucket:
+        case protocol::client_opcode::observe_seqno:
+        case protocol::client_opcode::evict_key:
+        case protocol::client_opcode::get_failover_log:
+        case protocol::client_opcode::last_closed_checkpoint:
+        case protocol::client_opcode::get_meta:
+        case protocol::client_opcode::upsert_with_meta:
+        case protocol::client_opcode::insert_with_meta:
+        case protocol::client_opcode::remove_with_meta:
+        case protocol::client_opcode::create_checkpoint:
+        case protocol::client_opcode::checkpoint_persistence:
+        case protocol::client_opcode::return_meta:
+        case protocol::client_opcode::get_random_key:
+        case protocol::client_opcode::seqno_persistence:
+        case protocol::client_opcode::get_keys:
+        case protocol::client_opcode::set_collections_manifest:
+        case protocol::client_opcode::get_collections_manifest:
+        case protocol::client_opcode::get_collection_id:
+        case protocol::client_opcode::get_scope_id:
+        case protocol::client_opcode::get_cluster_config:
+        case protocol::client_opcode::get_error_map:
+        case protocol::client_opcode::invalid:
+            Expects(false);
+    }
+    Expects(false);
+}
+
+} // namespace couchbase::tracing

data/ext/couchbase/tracing/noop_tracer.hxx

@@ -0,0 +1,50 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include "request_tracer.hxx"
+
+namespace couchbase::tracing
+{
+
+class noop_span : public request_span
+{
+    void add_tag(const std::string& /* name */, std::uint64_t /* value */) override
+    {
+    }
+
+    void add_tag(const std::string& /* name */, const std::string& /* value */) override
+    {
+    }
+
+    void end() override
+    {
+    }
+};
+
+class noop_tracer : public request_tracer
+{
+  public:
+    request_span* start_span(std::string /* name */, request_span* /* parent */) override
+    {
+        static noop_span instance{};
+        return &instance;
+    }
+};
+
+} // namespace couchbase::tracing

data/ext/couchbase/tracing/request_tracer.hxx

@@ -0,0 +1,77 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include "constants.hxx"
+
+namespace couchbase::tracing
+{
+
+class request_span
+{
+  public:
+    request_span() = default;
+    request_span(const request_span& other) = default;
+    request_span(request_span&& other) = default;
+    request_span& operator=(const request_span& other) = default;
+    request_span& operator=(request_span&& other) = default;
+    virtual ~request_span() = default;
+
+    explicit request_span(const std::string& name)
+      : name_(name)
+      , parent_(nullptr)
+    {
+    }
+    request_span(std::string name, request_span* parent)
+      : name_(std::move(name))
+      , parent_(parent)
+    {
+    }
+    virtual void add_tag(const std::string& name, std::uint64_t value) = 0;
+    virtual void add_tag(const std::string& name, const std::string& value) = 0;
+    virtual void end() = 0;
+
+    [[nodiscard]] const std::string& name() const
+    {
+        return name_;
+    }
+
+    [[nodiscard]] const request_span* parent() const
+    {
+        return parent_;
+    }
+
+  private:
+    std::string name_{};
+    request_span* parent_{ nullptr };
+};
+
+class request_tracer
+{
+  public:
+    request_tracer() = default;
+    request_tracer(const request_tracer& other) = default;
+    request_tracer(request_tracer&& other) = default;
+    request_tracer& operator=(const request_tracer& other) = default;
+    request_tracer& operator=(request_tracer&& other) = default;
+    virtual ~request_tracer() = default;
+
+    virtual request_span* start_span(std::string name, request_span* parent) = 0;
+};
+
+} // namespace couchbase::tracing