couchbase 3.0.0.beta.1 → 3.0.0

data/ext/couchbase/cluster.hxx

@@ -53,7 +53,8 @@ class cluster
     {
         origin_ = origin;
         if (origin_.options().enable_dns_srv) {
-            return do_dns_srv(std::forward<Handler>(handler));
+            return asio::post(asio::bind_executor(
+              ctx_, [this, handler = std::forward<Handler>(handler)]() mutable { return do_dns_srv(std::forward<Handler>(handler)); }));
         }
         do_open(std::forward<Handler>(handler));
     }
@@ -63,7 +64,7 @@ class cluster
     {
         asio::post(asio::bind_executor(ctx_, [this, handler = std::forward<Handler>(handler)]() {
             if (session_) {
-                session_->stop();
+                session_->stop(io::retry_reason::do_not_retry);
             }
             for (auto& bucket : buckets_) {
                 bucket.second->close();
@@ -103,7 +104,7 @@ class cluster
     template<class Request, class Handler>
     void execute_http(Request request, Handler&& handler)
     {
-        auto session = session_manager_->check_out(Request::type, origin_.get_username(), origin_.get_password());
+        auto session = session_manager_->check_out(Request::type, origin_.credentials());
         if (!session) {
             return handler(operations::make_response(std::make_error_code(error::common_errc::service_not_available), request, {}));
         }
@@ -157,9 +158,11 @@ class cluster
             tls_.set_options(asio::ssl::context::default_workarounds | asio::ssl::context::no_sslv2 | asio::ssl::context::no_sslv3);
             if (!origin_.options().trust_certificate.empty()) {
                 std::error_code ec{};
+                spdlog::debug(R"([{}]: use TLS certificate chain: "{}")", id_, origin_.options().trust_certificate);
                 tls_.use_certificate_chain_file(origin_.options().trust_certificate, ec);
                 if (ec) {
-                    spdlog::error("unable to load certificate chain \"{}\": {}", origin_.options().trust_certificate, ec.message());
+                    spdlog::error(
+                      "[{}]: unable to load certificate chain \"{}\": {}", id_, origin_.options().trust_certificate, ec.message());
                     return handler(ec);
                 }
             }
@@ -172,6 +175,21 @@ class cluster
                              "(https://wiki.wireshark.org/TLS). DO NOT USE THIS BUILD IN PRODUCTION",
                              TLS_KEY_LOG_FILE);
 #endif
+            if (origin_.credentials().uses_certificate()) {
+                std::error_code ec{};
+                spdlog::debug(R"([{}]: use TLS certificate: "{}")", id_, origin_.certificate_path());
+                tls_.use_certificate_file(origin_.certificate_path(), asio::ssl::context::file_format::pem, ec);
+                if (ec) {
+                    spdlog::error("[{}]: unable to load certificate \"{}\": {}", id_, origin_.certificate_path(), ec.message());
+                    return handler(ec);
+                }
+                spdlog::debug(R"([{}]: use TLS private key: "{}")", id_, origin_.key_path());
+                tls_.use_private_key_file(origin_.key_path(), asio::ssl::context::file_format::pem, ec);
+                if (ec) {
+                    spdlog::error("[{}]: unable to load private key \"{}\": {}", id_, origin_.key_path(), ec.message());
+                    return handler(ec);
+                }
+            }
             session_ = std::make_shared<io::mcbp_session>(id_, ctx_, tls_, origin_);
         } else {
             session_ = std::make_shared<io::mcbp_session>(id_, ctx_, origin_);

data/ext/couchbase/configuration.hxx

@@ -30,25 +30,25 @@ namespace couchbase
 {
 struct configuration {
     struct port_map {
-        std::optional<std::uint16_t> key_value;
-        std::optional<std::uint16_t> management;
-        std::optional<std::uint16_t> analytics;
-        std::optional<std::uint16_t> search;
-        std::optional<std::uint16_t> views;
-        std::optional<std::uint16_t> query;
+        std::optional<std::uint16_t> key_value{};
+        std::optional<std::uint16_t> management{};
+        std::optional<std::uint16_t> analytics{};
+        std::optional<std::uint16_t> search{};
+        std::optional<std::uint16_t> views{};
+        std::optional<std::uint16_t> query{};
     };
     struct alternate_address {
-        std::string name;
-        std::string hostname;
+        std::string name{};
+        std::string hostname{};
         port_map services_plain{};
         port_map services_tls{};
     };
     struct node {
         bool this_node{ false };
-        size_t index;
-        std::string hostname;
-        port_map services_plain;
-        port_map services_tls;
+        size_t index{};
+        std::string hostname{};
+        port_map services_plain{};
+        port_map services_tls{};
         std::map<std::string, alternate_address> alt{};
 
         [[nodiscard]] std::uint16_t port_or(service_type type, bool is_tls, std::uint16_t default_value) const
@@ -211,14 +211,14 @@ struct configuration {
         throw std::runtime_error("no nodes marked as this_node");
     }
 
-    std::pair<uint16_t, size_t> map_key(const std::string& key)
+    std::pair<std::uint16_t, std::int16_t> map_key(const std::string& key)
     {
         if (!vbmap.has_value()) {
             throw std::runtime_error("cannot map key: partition map is not available");
         }
         uint32_t crc = utils::hash_crc32(key.data(), key.size());
         uint16_t vbucket = uint16_t(crc % vbmap->size());
-        return std::make_pair(vbucket, static_cast<std::size_t>(vbmap->at(vbucket)[0]));
+        return std::make_pair(vbucket, vbmap->at(vbucket)[0]);
     }
 };
 

data/ext/couchbase/couchbase.cxx

@@ -28,6 +28,8 @@
 #include <snappy.h>
 
 #include <version.hxx>
+#include <platform/terminate_handler.h>
+
 #include <cluster.hxx>
 #include <operations.hxx>
 
@@ -165,6 +167,7 @@ cb_Backend_allocate(VALUE klass)
 }
 
 static VALUE eCouchbaseError;
+static VALUE eTimeout;
 static VALUE eAmbiguousTimeout;
 static VALUE eAuthenticationFailure;
 static VALUE eBucketExists;
@@ -197,6 +200,7 @@ static VALUE eGroupNotFound;
 static VALUE eIndexExists;
 static VALUE eIndexFailure;
 static VALUE eIndexNotFound;
+static VALUE eIndexNotReady;
 static VALUE eInternalServerFailure;
 static VALUE eInvalidArgument;
 static VALUE eJobQueueFull;
@@ -235,7 +239,9 @@ init_exceptions(VALUE mCouchbase)
     VALUE mError = rb_define_module_under(mCouchbase, "Error");
     eCouchbaseError = rb_define_class_under(mError, "CouchbaseError", rb_eStandardError);
 
-    eAmbiguousTimeout = rb_define_class_under(mError, "AmbiguousTimeout", eCouchbaseError);
+    eTimeout = rb_define_class_under(mError, "Timeout", eCouchbaseError);
+
+    eAmbiguousTimeout = rb_define_class_under(mError, "AmbiguousTimeout", eTimeout);
     eAuthenticationFailure = rb_define_class_under(mError, "AuthenticationFailure", eCouchbaseError);
     eBucketExists = rb_define_class_under(mError, "BucketExists", eCouchbaseError);
     eBucketNotFlushable = rb_define_class_under(mError, "BucketNotFlushable", eCouchbaseError);
@@ -267,6 +273,7 @@ init_exceptions(VALUE mCouchbase)
     eIndexExists = rb_define_class_under(mError, "IndexExists", eCouchbaseError);
     eIndexFailure = rb_define_class_under(mError, "IndexFailure", eCouchbaseError);
     eIndexNotFound = rb_define_class_under(mError, "IndexNotFound", eCouchbaseError);
+    eIndexNotReady = rb_define_class_under(mError, "IndexNotReady", eCouchbaseError);
     eInternalServerFailure = rb_define_class_under(mError, "InternalServerFailure", eCouchbaseError);
     eInvalidArgument = rb_define_class_under(mError, "InvalidArgument", rb_eArgError);
     eJobQueueFull = rb_define_class_under(mError, "JobQueueFull", eCouchbaseError);
@@ -286,7 +293,7 @@ init_exceptions(VALUE mCouchbase)
     eScopeNotFound = rb_define_class_under(mError, "ScopeNotFound", eCouchbaseError);
     eServiceNotAvailable = rb_define_class_under(mError, "ServiceNotAvailable", eCouchbaseError);
     eTemporaryFailure = rb_define_class_under(mError, "TemporaryFailure", eCouchbaseError);
-    eUnambiguousTimeout = rb_define_class_under(mError, "UnambiguousTimeout", eCouchbaseError);
+    eUnambiguousTimeout = rb_define_class_under(mError, "UnambiguousTimeout", eTimeout);
     eUnsupportedOperation = rb_define_class_under(mError, "UnsupportedOperation", eCouchbaseError);
     eUserNotFound = rb_define_class_under(mError, "UserNotFound", eCouchbaseError);
     eUserExists = rb_define_class_under(mError, "UserExists", eCouchbaseError);
@@ -450,6 +457,11 @@ cb__map_error_code(std::error_code ec, const std::string& message)
             case couchbase::error::query_errc::prepared_statement_failure:
                 return rb_exc_new_cstr(ePreparedStatementFailure, fmt::format("{}: {}", message, ec.message()).c_str());
         }
+    } else if (ec.category() == couchbase::error::detail::get_search_category()) {
+        switch (static_cast<couchbase::error::search_errc>(ec.value())) {
+            case couchbase::error::search_errc::index_not_ready:
+                return rb_exc_new_cstr(eIndexNotReady, fmt::format("{}: {}", message, ec.message()).c_str());
+        }
     } else if (ec.category() == couchbase::error::detail::get_view_category()) {
         switch (static_cast<couchbase::error::view_errc>(ec.value())) {
             case couchbase::error::view_errc::view_not_found:
@@ -510,7 +522,7 @@ cb__map_error_code(std::error_code ec, const std::string& message)
 }
 
 static VALUE
-cb_Backend_open(VALUE self, VALUE connection_string, VALUE username, VALUE password, VALUE options)
+cb_Backend_open(VALUE self, VALUE connection_string, VALUE credentials, VALUE options)
 {
     cb_backend_data* backend = nullptr;
     TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
@@ -519,26 +531,52 @@ cb_Backend_open(VALUE self, VALUE connection_string, VALUE username, VALUE passw
         rb_raise(rb_eArgError, "Cluster has been closed already");
     }
     Check_Type(connection_string, T_STRING);
-    Check_Type(username, T_STRING);
-    Check_Type(password, T_STRING);
+    Check_Type(credentials, T_HASH);
+
+    VALUE username = Qnil;
+    VALUE password = Qnil;
+
+    VALUE certificate_path = rb_hash_aref(credentials, rb_id2sym(rb_intern("certificate_path")));
+    VALUE key_path = rb_hash_aref(credentials, rb_id2sym(rb_intern("key_path")));
+    if (NIL_P(certificate_path) || NIL_P(key_path)) {
+        username = rb_hash_aref(credentials, rb_id2sym(rb_intern("username")));
+        password = rb_hash_aref(credentials, rb_id2sym(rb_intern("password")));
+        Check_Type(username, T_STRING);
+        Check_Type(password, T_STRING);
+    } else {
+        Check_Type(certificate_path, T_STRING);
+        Check_Type(key_path, T_STRING);
+    }
     if (!NIL_P(options)) {
         Check_Type(options, T_HASH);
     }
 
     VALUE exc = Qnil;
-    {
+    do {
         std::string input(RSTRING_PTR(connection_string), static_cast<size_t>(RSTRING_LEN(connection_string)));
         auto connstr = couchbase::utils::parse_connection_string(input);
-        std::string user(RSTRING_PTR(username), static_cast<size_t>(RSTRING_LEN(username)));
-        std::string pass(RSTRING_PTR(password), static_cast<size_t>(RSTRING_LEN(password)));
-        couchbase::origin origin(user, pass, std::move(connstr));
+        couchbase::cluster_credentials auth{};
+        if (NIL_P(certificate_path) || NIL_P(key_path)) {
+            auth.username.assign(RSTRING_PTR(username), static_cast<size_t>(RSTRING_LEN(username)));
+            auth.password.assign(RSTRING_PTR(password), static_cast<size_t>(RSTRING_LEN(password)));
+        } else {
+            if (!connstr.tls) {
+                exc = rb_exc_new_cstr(
+                  eInvalidArgument,
+                  fmt::format("Certificate authenticator requires TLS connection, check the schema of the connection string").c_str());
+                break;
+            }
+            auth.certificate_path.assign(RSTRING_PTR(certificate_path), static_cast<size_t>(RSTRING_LEN(certificate_path)));
+            auth.key_path.assign(RSTRING_PTR(key_path), static_cast<size_t>(RSTRING_LEN(key_path)));
+        }
+        couchbase::origin origin(auth, std::move(connstr));
         auto barrier = std::make_shared<std::promise<std::error_code>>();
         auto f = barrier->get_future();
         backend->cluster->open(origin, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
         if (auto ec = f.get()) {
             exc = cb__map_error_code(ec, fmt::format("unable open cluster at {}", origin.next_address().first));
         }
-    }
+    } while (false);
     if (!NIL_P(exc)) {
         rb_exc_raise(exc);
     }
@@ -1958,6 +1996,22 @@ cb_Backend_document_query(VALUE self, VALUE statement, VALUE options)
         if (!NIL_P(pipeline_batch)) {
             req.pipeline_batch = NUM2ULONG(pipeline_batch);
         }
+        VALUE scope_qualifier = rb_hash_aref(options, rb_id2sym(rb_intern("scope_qualifier")));
+        if (!NIL_P(scope_qualifier) && TYPE(scope_qualifier) == T_STRING) {
+            req.scope_qualifier.emplace(std::string(RSTRING_PTR(scope_qualifier), static_cast<std::size_t>(RSTRING_LEN(scope_qualifier))));
+        } else {
+            VALUE scope_name = rb_hash_aref(options, rb_id2sym(rb_intern("scope_name")));
+            if (!NIL_P(scope_name) && TYPE(scope_name) == T_STRING) {
+                req.scope_name.emplace(std::string(RSTRING_PTR(scope_name), static_cast<std::size_t>(RSTRING_LEN(scope_name))));
+                VALUE bucket_name = rb_hash_aref(options, rb_id2sym(rb_intern("bucket_name")));
+                if (NIL_P(bucket_name)) {
+                    exc = rb_exc_new_cstr(
+                      eInvalidArgument, fmt::format("bucket must be specified for query in scope \"{}\"", req.scope_name.value()).c_str());
+                    break;
+                }
+                req.bucket_name.emplace(std::string(RSTRING_PTR(bucket_name), static_cast<std::size_t>(RSTRING_LEN(bucket_name))));
+            }
+        }
         VALUE profile = rb_hash_aref(options, rb_id2sym(rb_intern("profile")));
         if (!NIL_P(profile)) {
             Check_Type(profile, T_SYMBOL);
@@ -2776,6 +2830,14 @@ cb_Backend_query_index_get_all(VALUE self, VALUE bucket_name, VALUE timeout)
                 rb_ary_push(index_key, rb_str_new(key.data(), static_cast<long>(key.size())));
             }
             rb_hash_aset(index, rb_id2sym(rb_intern("index_key")), index_key);
+            if (idx.scope_id) {
+                rb_hash_aset(
+                  index, rb_id2sym(rb_intern("scope_id")), rb_str_new(idx.scope_id->data(), static_cast<long>(idx.scope_id->size())));
+            }
+            if (idx.bucket_id) {
+                rb_hash_aset(
+                  index, rb_id2sym(rb_intern("bucket_id")), rb_str_new(idx.bucket_id->data(), static_cast<long>(idx.bucket_id->size())));
+            }
             if (idx.condition) {
                 rb_hash_aset(
                   index, rb_id2sym(rb_intern("condition")), rb_str_new(idx.condition->data(), static_cast<long>(idx.condition->size())));
@@ -2840,6 +2902,14 @@ cb_Backend_query_index_create(VALUE self, VALUE bucket_name, VALUE index_name, V
             if (!NIL_P(condition)) {
                 req.condition.emplace(std::string(RSTRING_PTR(condition), static_cast<std::size_t>(RSTRING_LEN(condition))));
             } /* else use backend default */
+            VALUE scope_name = rb_hash_aref(options, rb_id2sym(rb_intern("scope_name")));
+            if (TYPE(scope_name) == T_STRING) {
+                req.scope_name.assign(RSTRING_PTR(scope_name), static_cast<size_t>(RSTRING_LEN(scope_name)));
+            }
+            VALUE collection_name = rb_hash_aref(options, rb_id2sym(rb_intern("collection_name")));
+            if (TYPE(scope_name) == T_STRING) {
+                req.collection_name.assign(RSTRING_PTR(collection_name), static_cast<size_t>(RSTRING_LEN(collection_name)));
+            }
         }
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_create_response>>();
@@ -2907,6 +2977,14 @@ cb_Backend_query_index_drop(VALUE self, VALUE bucket_name, VALUE index_name, VAL
             } else if (ignore_if_does_not_exist == Qfalse) {
                 req.ignore_if_does_not_exist = false;
             } /* else use backend default */
+            VALUE scope_name = rb_hash_aref(options, rb_id2sym(rb_intern("scope_name")));
+            if (TYPE(scope_name) == T_STRING) {
+                req.scope_name.assign(RSTRING_PTR(scope_name), static_cast<size_t>(RSTRING_LEN(scope_name)));
+            }
+            VALUE collection_name = rb_hash_aref(options, rb_id2sym(rb_intern("collection_name")));
+            if (TYPE(scope_name) == T_STRING) {
+                req.collection_name.assign(RSTRING_PTR(collection_name), static_cast<size_t>(RSTRING_LEN(collection_name)));
+            }
         }
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_drop_response>>();
@@ -2990,6 +3068,14 @@ cb_Backend_query_index_create_primary(VALUE self, VALUE bucket_name, VALUE optio
             if (!NIL_P(index_name)) {
                 req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
             } /* else use backend default */
+            VALUE scope_name = rb_hash_aref(options, rb_id2sym(rb_intern("scope_name")));
+            if (TYPE(scope_name) == T_STRING) {
+                req.scope_name.assign(RSTRING_PTR(scope_name), static_cast<size_t>(RSTRING_LEN(scope_name)));
+            }
+            VALUE collection_name = rb_hash_aref(options, rb_id2sym(rb_intern("collection_name")));
+            if (TYPE(scope_name) == T_STRING) {
+                req.collection_name.assign(RSTRING_PTR(collection_name), static_cast<size_t>(RSTRING_LEN(collection_name)));
+            }
         }
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_create_response>>();
@@ -3061,6 +3147,14 @@ cb_Backend_query_index_drop_primary(VALUE self, VALUE bucket_name, VALUE options
                 req.is_primary = false;
                 req.bucket_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
             }
+            VALUE scope_name = rb_hash_aref(options, rb_id2sym(rb_intern("scope_name")));
+            if (TYPE(scope_name) == T_STRING) {
+                req.scope_name.assign(RSTRING_PTR(scope_name), static_cast<size_t>(RSTRING_LEN(scope_name)));
+            }
+            VALUE collection_name = rb_hash_aref(options, rb_id2sym(rb_intern("collection_name")));
+            if (TYPE(scope_name) == T_STRING) {
+                req.collection_name.assign(RSTRING_PTR(collection_name), static_cast<size_t>(RSTRING_LEN(collection_name)));
+            }
         }
 
         auto barrier = std::make_shared<std::promise<couchbase::operations::query_index_drop_response>>();
@@ -5347,7 +5441,7 @@ init_backend(VALUE mCouchbase)
 {
     VALUE cBackend = rb_define_class_under(mCouchbase, "Backend", rb_cBasicObject);
     rb_define_alloc_func(cBackend, cb_Backend_allocate);
-    rb_define_method(cBackend, "open", VALUE_FUNC(cb_Backend_open), 4);
+    rb_define_method(cBackend, "open", VALUE_FUNC(cb_Backend_open), 3);
     rb_define_method(cBackend, "close", VALUE_FUNC(cb_Backend_close), 0);
     rb_define_method(cBackend, "open_bucket", VALUE_FUNC(cb_Backend_open_bucket), 2);
 
@@ -5435,11 +5529,13 @@ init_logger()
 
     auto env_val = spdlog::details::os::getenv("COUCHBASE_BACKEND_LOG_LEVEL");
     if (env_val.empty()) {
-        spdlog::set_level(spdlog::level::critical);
+        spdlog::set_level(spdlog::level::warn);
     } else {
         auto levels = spdlog::cfg::helpers::extract_levels(env_val);
         spdlog::details::registry::instance().update_levels(std::move(levels));
     }
+
+    couchbase::platform::install_backtrace_terminate_handler();
 }
 
 extern "C" {

data/ext/couchbase/error_map.hxx

@@ -20,12 +20,112 @@
 namespace couchbase
 {
 struct error_map {
+    enum class attribute {
+        /**
+         * The operation was successful for those situations where the error code is indicating successful (i.e. subdoc 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 specifies that the requested item is currently locked.
+         */
+        item_locked,
+
+        /**
+         * This attribute means that the error is related to operating on a soft-deleted document.
+         */
+        item_deleted,
+    };
+
     struct error_info {
         std::uint16_t code;
         std::string name;
         std::string description;
-        std::set<std::string> attributes;
+        std::set<attribute> attributes;
+
+        bool has_retry_attribute()
+        {
+            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;
@@ -51,7 +151,44 @@ struct traits<couchbase::error_map> {
             ei.name = info.at("name").get_string();
             ei.description = info.at("desc").get_string();
             for (const auto& a : info.at("attrs").get_array()) {
-                ei.attributes.insert(a.get_string());
+                const std::string& attr_val = a.get_string();
+                if (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 {
+                    spdlog::warn(R"(skipping unknown attribute "{}" in error map for code={} and name="{}")", attr_val, ei.code, ei.name);
+                }
             }
             result.errors.emplace(ei.code, ei);
         }
@@ -59,3 +196,66 @@ struct traits<couchbase::error_map> {
     }
 };
 } // namespace tao::json
+
+template<>
+struct fmt::formatter<couchbase::error_map::attribute> : formatter<string_view> {
+    template<typename FormatContext>
+    auto format(couchbase::error_map::attribute attr, FormatContext& ctx)
+    {
+        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;
+        }
+        return formatter<string_view>::format(name, ctx);
+    }
+};