couchbase 4.1.2 → 4.1.3

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/topology/configuration_json.hxx

@@ -1,259 +0,0 @@
-/* -*- 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 <couchbase/topology/configuration.hxx>
-
-#include <tao/json/forward.hpp>
-
-namespace tao::json
-{
-template<>
-struct traits<couchbase::topology::configuration> {
-    template<template<typename...> class Traits>
-    static couchbase::topology::configuration as(const tao::json::basic_value<Traits>& v)
-    {
-        couchbase::topology::configuration result;
-        result.id = couchbase::uuid::random();
-        result.epoch = v.template optional<std::int64_t>("revEpoch");
-        result.rev = v.template optional<std::int64_t>("rev");
-
-        if (auto* node_locator = v.find("nodeLocator"); node_locator != nullptr && node_locator->is_string()) {
-            if (node_locator->get_string() == "ketama") {
-                result.node_locator = couchbase::topology::configuration::node_locator_type::ketama;
-            } else {
-                result.node_locator = couchbase::topology::configuration::node_locator_type::vbucket;
-            }
-        }
-
-        if (auto* nodes_ext = v.find("nodesExt"); nodes_ext != nullptr) {
-            size_t index = 0;
-            for (const auto& j : nodes_ext->get_array()) {
-                couchbase::topology::configuration::node n;
-                n.index = index++;
-                const auto& o = j.get_object();
-                if (const auto& this_node = o.find("thisNode"); this_node != o.end() && this_node->second.get_boolean()) {
-                    n.this_node = true;
-                }
-                if (const auto& hostname = o.find("hostname"); hostname != o.end()) {
-                    n.hostname = hostname->second.get_string();
-                    n.hostname = n.hostname.substr(0, n.hostname.rfind(':'));
-                }
-                const auto& s = o.at("services");
-                n.services_plain.key_value = s.template optional<std::uint16_t>("kv");
-                n.services_plain.management = s.template optional<std::uint16_t>("mgmt");
-                n.services_plain.search = s.template optional<std::uint16_t>("fts");
-                n.services_plain.analytics = s.template optional<std::uint16_t>("cbas");
-                n.services_plain.query = s.template optional<std::uint16_t>("n1ql");
-                n.services_plain.views = s.template optional<std::uint16_t>("capi");
-                n.services_plain.eventing = s.template optional<std::uint16_t>("eventingAdminPort");
-                n.services_tls.key_value = s.template optional<std::uint16_t>("kvSSL");
-                n.services_tls.management = s.template optional<std::uint16_t>("mgmtSSL");
-                n.services_tls.search = s.template optional<std::uint16_t>("ftsSSL");
-                n.services_tls.analytics = s.template optional<std::uint16_t>("cbasSSL");
-                n.services_tls.query = s.template optional<std::uint16_t>("n1qlSSL");
-                n.services_tls.views = s.template optional<std::uint16_t>("capiSSL");
-                n.services_tls.eventing = s.template optional<std::uint16_t>("eventingSSL");
-                {
-                    const auto& alt = o.find("alternateAddresses");
-                    if (alt != o.end()) {
-                        for (const auto& entry : alt->second.get_object()) {
-                            couchbase::topology::configuration::alternate_address addr;
-                            addr.name = entry.first;
-                            addr.hostname = entry.second.at("hostname").get_string();
-                            const auto& ports = entry.second.find("ports");
-                            addr.services_plain.key_value = ports->template optional<std::uint16_t>("kv");
-                            addr.services_plain.management = ports->template optional<std::uint16_t>("mgmt");
-                            addr.services_plain.search = ports->template optional<std::uint16_t>("fts");
-                            addr.services_plain.analytics = ports->template optional<std::uint16_t>("cbas");
-                            addr.services_plain.query = ports->template optional<std::uint16_t>("n1ql");
-                            addr.services_plain.views = ports->template optional<std::uint16_t>("capi");
-                            addr.services_plain.eventing = ports->template optional<std::uint16_t>("eventingAdminPort");
-                            addr.services_tls.key_value = ports->template optional<std::uint16_t>("kvSSL");
-                            addr.services_tls.management = ports->template optional<std::uint16_t>("mgmtSSL");
-                            addr.services_tls.search = ports->template optional<std::uint16_t>("ftsSSL");
-                            addr.services_tls.analytics = ports->template optional<std::uint16_t>("cbasSSL");
-                            addr.services_tls.query = ports->template optional<std::uint16_t>("n1qlSSL");
-                            addr.services_tls.views = ports->template optional<std::uint16_t>("capiSSL");
-                            addr.services_tls.eventing = ports->template optional<std::uint16_t>("eventingSSL");
-                            n.alt.emplace(entry.first, addr);
-                        }
-                    }
-                }
-                result.nodes.emplace_back(n);
-            }
-        } else {
-            if (result.node_locator == couchbase::topology::configuration::node_locator_type::vbucket) {
-                const auto* m = v.find("vBucketServerMap");
-                const auto& nodes = v.at("nodes").get_array();
-                if (m != nullptr) {
-                    size_t index = 0;
-                    if (const auto* s = m->find("serverList"); s != nullptr && s->is_array()) {
-                        for (const auto& j : s->get_array()) {
-                            couchbase::topology::configuration::node n;
-                            n.index = index++;
-                            const auto& address = j.get_string();
-                            n.hostname = address.substr(0, address.rfind(':'));
-                            n.services_plain.key_value = static_cast<std::uint16_t>(std::stoul(address.substr(address.rfind(':') + 1)));
-                            if (n.index >= nodes.size()) {
-                                continue;
-                            }
-                            if (const auto& np = nodes[n.index]; np.is_object()) {
-                                const auto& o = np.get_object();
-
-                                if (const auto& this_node = o.find("thisNode"); this_node != o.end() && this_node->second.get_boolean()) {
-                                    n.this_node = true;
-                                }
-                                const auto& p = o.at("ports");
-                                if (auto https_views = p.template optional<std::int64_t>("httpsCAPI");
-                                    https_views && https_views.value() > 0 &&
-                                    https_views.value() < std::numeric_limits<std::uint16_t>::max()) {
-                                    n.services_tls.views = static_cast<std::uint16_t>(https_views.value());
-                                }
-                                if (auto https_mgmt = p.template optional<std::int64_t>("httpsMgmt");
-                                    https_mgmt && https_mgmt.value() > 0 &&
-                                    https_mgmt.value() < std::numeric_limits<std::uint16_t>::max()) {
-                                    n.services_tls.management = static_cast<std::uint16_t>(https_mgmt.value());
-                                }
-                                const auto& h = o.at("hostname").get_string();
-                                n.services_plain.management = static_cast<std::uint16_t>(std::stoul(h.substr(h.rfind(':') + 1)));
-                                std::string capi = o.at("couchApiBase").get_string();
-                                auto slash = capi.rfind('/');
-                                auto colon = capi.rfind(':', slash);
-                                n.services_plain.views = static_cast<std::uint16_t>(std::stoul(capi.substr(colon + 1, slash)));
-                            }
-                            result.nodes.emplace_back(n);
-                        }
-                    }
-                }
-            } else {
-                size_t index = 0;
-                for (const auto& node : v.at("nodes").get_array()) {
-                    couchbase::topology::configuration::node n;
-                    n.index = index++;
-                    const auto& o = node.get_object();
-
-                    if (const auto& this_node = o.find("thisNode"); this_node != o.end() && this_node->second.get_boolean()) {
-                        n.this_node = true;
-                    }
-                    const auto& p = o.at("ports");
-                    if (auto direct = p.template optional<std::int64_t>("direct");
-                        direct && direct.value() > 0 && direct.value() < std::numeric_limits<std::uint16_t>::max()) {
-                        n.services_plain.key_value = static_cast<std::uint16_t>(direct.value());
-                    }
-                    if (auto https_views = p.template optional<std::int64_t>("httpsCAPI");
-                        https_views && https_views.value() > 0 && https_views.value() < std::numeric_limits<std::uint16_t>::max()) {
-                        n.services_tls.views = static_cast<std::uint16_t>(https_views.value());
-                    }
-
-                    if (auto https_mgmt = p.template optional<std::int64_t>("httpsMgmt");
-                        https_mgmt && https_mgmt.value() > 0 && https_mgmt.value() < std::numeric_limits<std::uint16_t>::max()) {
-                        n.services_tls.management = static_cast<std::uint16_t>(https_mgmt.value());
-                    }
-                    const auto& h = o.at("hostname").get_string();
-                    auto colon = h.rfind(':');
-                    n.hostname = h.substr(0, colon);
-                    n.services_plain.management = static_cast<std::uint16_t>(std::stoul(h.substr(colon + 1)));
-
-                    std::string capi = o.at("couchApiBase").get_string();
-                    auto slash = capi.rfind('/');
-                    colon = capi.rfind(':', slash);
-                    n.services_plain.views = static_cast<std::uint16_t>(std::stoul(capi.substr(colon + 1, slash)));
-
-                    result.nodes.emplace_back(n);
-                }
-            }
-        }
-        if (const auto m = v.find("uuid"); m != nullptr) {
-            result.uuid = m->get_string();
-        }
-        if (const auto m = v.find("collectionsManifestUid"); m != nullptr) {
-            result.collections_manifest_uid = std::stoull(m->get_string(), nullptr, 16);
-        }
-        if (const auto m = v.find("name"); m != nullptr) {
-            result.bucket = m->get_string();
-        }
-
-        if (const auto m = v.find("vBucketServerMap"); m != nullptr) {
-            const auto& o = m->get_object();
-            if (const auto f = o.find("numReplicas"); f != o.end()) {
-                result.num_replicas = f->second.template as<std::uint32_t>();
-            }
-            if (const auto f = o.find("vBucketMap"); f != o.end()) {
-                const auto& vb = f->second.get_array();
-                couchbase::topology::configuration::vbucket_map vbmap;
-                vbmap.resize(vb.size());
-                for (size_t i = 0; i < vb.size(); i++) {
-                    const auto& p = vb[i].get_array();
-                    vbmap[i].resize(p.size());
-                    for (size_t n = 0; n < p.size(); n++) {
-                        vbmap[i][n] = p[n].template as<std::int16_t>();
-                    }
-                }
-                result.vbmap = vbmap;
-            }
-        }
-        if (const auto m = v.find("bucketCapabilities"); m != nullptr && m->is_array()) {
-            for (const auto& entry : m->get_array()) {
-                const auto& name = entry.get_string();
-                if (name == "couchapi") {
-                    result.bucket_capabilities.insert(couchbase::bucket_capability::couchapi);
-                } else if (name == "collections") {
-                    result.bucket_capabilities.insert(couchbase::bucket_capability::collections);
-                } else if (name == "durableWrite") {
-                    result.bucket_capabilities.insert(couchbase::bucket_capability::durable_write);
-                } else if (name == "tombstonedUserXAttrs") {
-                    result.bucket_capabilities.insert(couchbase::bucket_capability::tombstoned_user_xattrs);
-                } else if (name == "dcp") {
-                    result.bucket_capabilities.insert(couchbase::bucket_capability::dcp);
-                } else if (name == "cbhello") {
-                    result.bucket_capabilities.insert(couchbase::bucket_capability::cbhello);
-                } else if (name == "touch") {
-                    result.bucket_capabilities.insert(couchbase::bucket_capability::touch);
-                } else if (name == "cccp") {
-                    result.bucket_capabilities.insert(couchbase::bucket_capability::cccp);
-                } else if (name == "xdcrCheckpointing") {
-                    result.bucket_capabilities.insert(couchbase::bucket_capability::xdcr_checkpointing);
-                } else if (name == "nodesExt") {
-                    result.bucket_capabilities.insert(couchbase::bucket_capability::nodes_ext);
-                } else if (name == "xattr") {
-                    result.bucket_capabilities.insert(couchbase::bucket_capability::xattr);
-                }
-            }
-        }
-        if (const auto m = v.find("clusterCapabilities"); m != nullptr && m->is_object()) {
-            if (const auto nc = m->find("n1ql"); nc != nullptr && nc->is_array()) {
-                for (const auto& entry : nc->get_array()) {
-                    if (const auto& name = entry.get_string(); name == "costBasedOptimizer") {
-                        result.cluster_capabilities.insert(couchbase::cluster_capability::n1ql_cost_based_optimizer);
-                    } else if (name == "indexAdvisor") {
-                        result.cluster_capabilities.insert(couchbase::cluster_capability::n1ql_index_advisor);
-                    } else if (name == "javaScriptFunctions") {
-                        result.cluster_capabilities.insert(couchbase::cluster_capability::n1ql_javascript_functions);
-                    } else if (name == "inlineFunctions") {
-                        result.cluster_capabilities.insert(couchbase::cluster_capability::n1ql_inline_functions);
-                    } else if (name == "enhancedPreparedStatements") {
-                        result.cluster_capabilities.insert(couchbase::cluster_capability::n1ql_enhanced_prepared_statements);
-                    }
-                }
-            }
-        }
-        return result;
-    }
-};
-} // namespace tao::json

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/topology/error_map.hxx

@@ -1,149 +0,0 @@
-/* -*- 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 <couchbase/platform/uuid.h>
-
-#include <map>
-#include <set>
-
-
-namespace couchbase
-{
-struct error_map {
-    /**
-     * This enum defines known attributes, that could be associated with the error code in the error map.
-     * Complete list could be found at https://github.com/couchbase/kv_engine/blob/master/docs/ErrorMap.md#error-attributes.
-     */
-    enum class attribute {
-        /**
-         * The operation was successful for those situations where the error code is indicating successful (i.e. subdocument operations
-         * carried out on a deleted document)
-         */
-        success,
-
-        /**
-         * This attribute means that the error is related to a constraint failure regarding the item itself, i.e. the item does not exist,
-         * already exists, or its current value makes the current operation impossible. Retrying the operation when the item's value or
-         * status has changed may succeed.
-         */
-        item_only,
-
-        /**
-         * This attribute means that a user's input was invalid because it violates the semantics of the operation, or exceeds some
-         * predefined limit.
-         */
-        invalid_input,
-
-        /**
-         * The client's cluster map may be outdated and requires updating. The client should obtain a newer configuration.
-         */
-        fetch_config,
-
-        /**
-         * The current connection is no longer valid. The client must reconnect to the server. Note that the presence of other attributes
-         * may indicate an alternate remedy to fixing the connection without a disconnect, but without special remedial action a disconnect
-         * is needed.
-         */
-        conn_state_invalidated,
-
-        /**
-         * The operation failed because the client failed to authenticate or is not authorized to perform this operation. Note that this
-         * error in itself does not mean the connection is invalid, unless conn-state-invalidated is also present.
-         */
-        auth,
-
-        /**
-         * This error code must be handled specially. If it is not handled, the connection must be dropped.
-         */
-        special_handling,
-
-        /**
-         * The operation is not supported, possibly because the of server version, bucket type, or current user.
-         */
-        support,
-
-        /**
-         * This error is transient. Note that this does not mean the error is retriable.
-         */
-        temp,
-
-        /**
-         * This is an internal error in the server.
-         */
-        internal,
-
-        /**
-         * The operation may be retried immediately.
-         */
-        retry_now,
-
-        /**
-         * The operation may be retried after some time.
-         */
-        retry_later,
-
-        /**
-         * The error is related to the subdocument subsystem.
-         */
-        subdoc,
-
-        /**
-         * The error is related to the DCP subsystem.
-         */
-        dcp,
-
-        /**
-         * Use retry specifications from the server.
-         */
-        auto_retry,
-
-        /**
-         * This attribute means that the error is related to operating on a locked document.
-         */
-        item_locked,
-
-        /**
-         * This attribute means that the error is related to operating on a soft-deleted document.
-         */
-        item_deleted,
-
-        /**
-         * The error is related to rate limitation for the client (version 2)
-         */
-        rate_limit,
-    };
-
-    struct error_info {
-        std::uint16_t code;
-        std::string name;
-        std::string description;
-        std::set<attribute> attributes;
-
-        [[nodiscard]] bool has_retry_attribute() const
-        {
-            return attributes.find(attribute::retry_now) != attributes.end() || attributes.find(attribute::retry_later) != attributes.end();
-        }
-    };
-
-    uuid::uuid_t id;
-    uint16_t version;
-    uint16_t revision{};
-    std::map<std::uint16_t, error_info> errors{};
-};
-} // namespace couchbase

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/topology/error_map_fmt.hxx

@@ -1,94 +0,0 @@
-/* -*- 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 <couchbase/topology/error_map.hxx>
-
-#include <fmt/core.h>
-
-template<>
-struct fmt::formatter<couchbase::error_map::attribute> {
-    template<typename ParseContext>
-    constexpr auto parse(ParseContext& ctx)
-    {
-        return ctx.begin();
-    }
-
-    template<typename FormatContext>
-    auto format(couchbase::error_map::attribute attr, FormatContext& ctx) const
-    {
-        string_view name = "unknown";
-        switch (attr) {
-            case couchbase::error_map::attribute::success:
-                name = "success";
-                break;
-            case couchbase::error_map::attribute::item_only:
-                name = "item-only";
-                break;
-            case couchbase::error_map::attribute::invalid_input:
-                name = "invalid-input";
-                break;
-            case couchbase::error_map::attribute::fetch_config:
-                name = "fetch-config";
-                break;
-            case couchbase::error_map::attribute::conn_state_invalidated:
-                name = "conn-state-invalidated";
-                break;
-            case couchbase::error_map::attribute::auth:
-                name = "auth";
-                break;
-            case couchbase::error_map::attribute::special_handling:
-                name = "special-handling";
-                break;
-            case couchbase::error_map::attribute::support:
-                name = "support";
-                break;
-            case couchbase::error_map::attribute::temp:
-                name = "temp";
-                break;
-            case couchbase::error_map::attribute::internal:
-                name = "internal";
-                break;
-            case couchbase::error_map::attribute::retry_now:
-                name = "retry-now";
-                break;
-            case couchbase::error_map::attribute::retry_later:
-                name = "retry-later";
-                break;
-            case couchbase::error_map::attribute::subdoc:
-                name = "subdoc";
-                break;
-            case couchbase::error_map::attribute::dcp:
-                name = "dcp";
-                break;
-            case couchbase::error_map::attribute::auto_retry:
-                name = "auto-retry";
-                break;
-            case couchbase::error_map::attribute::item_locked:
-                name = "item-locked";
-                break;
-            case couchbase::error_map::attribute::item_deleted:
-                name = "item-deleted";
-                break;
-            case couchbase::error_map::attribute::rate_limit:
-                name = "rate-limit";
-                break;
-        }
-        return format_to(ctx.out(), "{}", name);
-    }
-};

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/topology/error_map_json.hxx

@@ -1,88 +0,0 @@
-/* -*- 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 <couchbase/topology/error_map.hxx>
-
-#include <gsl/narrow>
-#include <tao/json/forward.hpp>
-
-namespace tao::json
-{
-template<>
-struct traits<couchbase::error_map> {
-    template<template<typename...> class Traits>
-    static couchbase::error_map as(const tao::json::basic_value<Traits>& v)
-    {
-        couchbase::error_map result;
-        result.id = couchbase::uuid::random();
-        result.version = v.at("revision").template as<std::uint16_t>();
-        result.revision = v.at("revision").template as<std::uint16_t>();
-        for (const auto& [code, definition] : v.at("errors").get_object()) {
-            couchbase::error_map::error_info ei;
-            ei.code = gsl::narrow_cast<std::uint16_t>(std::stoul(code, nullptr, 16));
-            const auto& info = definition.get_object();
-            ei.name = info.at("name").get_string();
-            ei.description = info.at("desc").get_string();
-            for (const auto& attribute : info.at("attrs").get_array()) {
-                if (const std::string& attr_val = attribute.get_string(); attr_val == "success") {
-                    ei.attributes.insert(couchbase::error_map::attribute::success);
-                } else if (attr_val == "item-only") {
-                    ei.attributes.insert(couchbase::error_map::attribute::item_only);
-                } else if (attr_val == "invalid-input") {
-                    ei.attributes.insert(couchbase::error_map::attribute::invalid_input);
-                } else if (attr_val == "fetch-config") {
-                    ei.attributes.insert(couchbase::error_map::attribute::fetch_config);
-                } else if (attr_val == "conn-state-invalidated") {
-                    ei.attributes.insert(couchbase::error_map::attribute::conn_state_invalidated);
-                } else if (attr_val == "auth") {
-                    ei.attributes.insert(couchbase::error_map::attribute::auth);
-                } else if (attr_val == "special-handling") {
-                    ei.attributes.insert(couchbase::error_map::attribute::special_handling);
-                } else if (attr_val == "support") {
-                    ei.attributes.insert(couchbase::error_map::attribute::support);
-                } else if (attr_val == "temp") {
-                    ei.attributes.insert(couchbase::error_map::attribute::temp);
-                } else if (attr_val == "internal") {
-                    ei.attributes.insert(couchbase::error_map::attribute::internal);
-                } else if (attr_val == "retry-now") {
-                    ei.attributes.insert(couchbase::error_map::attribute::retry_now);
-                } else if (attr_val == "retry-later") {
-                    ei.attributes.insert(couchbase::error_map::attribute::retry_later);
-                } else if (attr_val == "subdoc") {
-                    ei.attributes.insert(couchbase::error_map::attribute::subdoc);
-                } else if (attr_val == "dcp") {
-                    ei.attributes.insert(couchbase::error_map::attribute::dcp);
-                } else if (attr_val == "auto-retry") {
-                    ei.attributes.insert(couchbase::error_map::attribute::auto_retry);
-                } else if (attr_val == "item-locked") {
-                    ei.attributes.insert(couchbase::error_map::attribute::item_locked);
-                } else if (attr_val == "item-deleted") {
-                    ei.attributes.insert(couchbase::error_map::attribute::item_deleted);
-                } else if (attr_val == "rate-limit") {
-                    ei.attributes.insert(couchbase::error_map::attribute::rate_limit);
-                } else {
-                    LOG_WARNING(R"(skipping unknown attribute "{}" in error map for code={} and name="{}")", attr_val, ei.code, ei.name);
-                }
-            }
-            result.errors.emplace(ei.code, ei);
-        }
-        return result;
-    }
-};
-} // namespace tao::json

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/tracing/CMakeLists.txt

@@ -1,9 +0,0 @@
-add_library(couchbase_tracing OBJECT threshold_logging_tracer.cxx)
-set_target_properties(couchbase_tracing PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_link_libraries(
-  couchbase_tracing
-  PRIVATE project_options
-          project_warnings
-          fmt::fmt
-          spdlog::spdlog)
-target_include_directories(couchbase_tracing PRIVATE ${PROJECT_SOURCE_DIR})