couchbase 3.2.2 → 3.2.5

package/deps/lcb/src/cntl.cc

@@ -21,6 +21,7 @@
 #include <lcbio/iotable.h>
 #include <mcserver/negotiate.h>
 #include <lcbio/ssl.h>
+#include "n1ql/query_utils.hh"
 
 #define LOGARGS(instance, lvl) instance->settings, "cntl", LCB_LOG_##lvl, __FILE__, __LINE__
 
@@ -238,7 +239,35 @@ HANDLER(select_bucket_handler){RETURN_GET_SET(int, LCBT_SETTING(instance, select
 
 HANDLER(log_redaction_handler){RETURN_GET_SET(int, LCBT_SETTING(instance, log_redaction))}
 
-HANDLER(enable_tracing_handler){RETURN_GET_SET(int, LCBT_SETTING(instance, use_tracing))}
+HANDLER(enable_tracing_handler)
+{
+    if (mode == LCB_CNTL_GET) {
+        RETURN_GET_ONLY(int, instance->settings->use_tracing)
+    } else if (mode == LCB_CNTL_SET) {
+        if (arg == nullptr) {
+            return LCB_ERR_INVALID_ARGUMENT;
+        }
+        int enabled = *(static_cast<int *>(arg));
+        if (enabled) {
+            if (instance->settings->use_tracing) {
+                /* do nothing */
+                return LCB_SUCCESS;
+            }
+            instance->settings->tracer = lcbtrace_new(instance, LCBTRACE_F_THRESHOLD);
+            instance->settings->use_tracing = true;
+            return LCB_SUCCESS;
+        } else {
+            if (instance->settings->use_tracing) {
+                lcbtrace_destroy(instance->settings->tracer);
+                instance->settings->tracer = nullptr;
+                instance->settings->use_tracing = false;
+            }
+            return LCB_SUCCESS;
+        }
+    } else {
+        return LCB_ERR_CONTROL_UNSUPPORTED_MODE;
+    }
+}
 
 HANDLER(enable_errmap_handler){RETURN_GET_SET(int, LCBT_SETTING(instance, use_errmap))}
 
@@ -858,14 +887,19 @@ typedef struct {
 
 static lcb_STATUS convert_timevalue(const char *arg, u_STRCONVERT *u)
 {
-    double dtmp;
-    char *end = nullptr;
-    errno = 0;
-    dtmp = std::strtod(arg, &end);
-    if (errno == ERANGE || end == arg) {
-        return LCB_ERR_CONTROL_INVALID_ARGUMENT;
+    try {
+        auto tmo_ns = lcb_parse_golang_duration(arg);
+        u->u32 = static_cast<std::uint32_t>(std::chrono::duration_cast<std::chrono::microseconds>(tmo_ns).count());
+    } catch (const lcb_duration_parse_error &) {
+        double dtmp;
+        char *end = nullptr;
+        errno = 0;
+        dtmp = std::strtod(arg, &end);
+        if (errno == ERANGE || end == arg) {
+            return LCB_ERR_CONTROL_INVALID_ARGUMENT;
+        }
+        u->u32 = static_cast<std::uint32_t>(dtmp * (double)1000000);
     }
-    u->u32 = static_cast<std::uint32_t>(dtmp * (double)1000000);
     return LCB_SUCCESS;
 }
 

package/deps/lcb/src/dns-srv.cc

@@ -105,9 +105,11 @@ lcb_STATUS lcb::dnssrv_query(const char *addr, Hostlist &hs)
     }
 
     for (cur = root; cur; cur = cur->pNext) {
-        // Use the ASCII version of the DNS lookup structure
-        const DNS_SRV_DATAA *srv = &cur->Data.SRV;
-        hs.add(srv->pNameTarget, srv->wPort);
+        if(cur->wType == DNS_TYPE_SRV) {
+            // Use the ASCII version of the DNS lookup structure
+            const DNS_SRV_DATAA *srv = &cur->Data.SRV;
+            hs.add(srv->pNameTarget, srv->wPort);
+        }
     }
     DnsRecordListFree(root, DnsFreeRecordList);
     return LCB_SUCCESS;

package/deps/lcb/src/errmap.cc

@@ -131,8 +131,7 @@ ErrorMap::ParseStatus ErrorMap::parse(const char *s, size_t n, std::string &errm
         return PARSE_ERROR;
     }
 
-    Json::Value::const_iterator ii = errsJson.begin();
-    for (; ii != errsJson.end(); ++ii) {
+    for (Json::Value::const_iterator ii = errsJson.begin(); ii != errsJson.end(); ++ii) {
         // Key is the version in hex
         unsigned ec = 0;
         if (sscanf(ii.key().asCString(), "%x", &ec) != 1) {
@@ -155,14 +154,11 @@ ErrorMap::ParseStatus ErrorMap::parse(const char *s, size_t n, std::string &errm
             return PARSE_ERROR;
         }
 
-        Json::Value::const_iterator jj = attrs.begin();
-        for (; jj != attrs.end(); ++jj) {
-            ErrorAttribute attr = getAttribute(jj->asString());
-            if (attr == INVALID_ATTRIBUTE) {
-                errmsg = "unknown attribute received";
-                return UNKNOWN_VERSION;
+        for (const auto &jj : attrs) {
+            ErrorAttribute attr = getAttribute(jj.asString());
+            if (attr != INVALID_ATTRIBUTE) {
+                error.attributes.insert(attr);
             }
-            error.attributes.insert(attr);
         }
         if (error.hasAttribute(AUTO_RETRY)) {
             const Json::Value &retryJson = errorJson["retry"];

package/deps/lcb/src/errmap.h

@@ -124,7 +124,11 @@ enum ErrorAttribute {
      * This attribute means that the error is related to operating on                                                  \
      * a soft-deleted document.                                                                                        \
      */                                                                                                                \
-    X(ITEM_DELETED, "item-deleted")
+    X(ITEM_DELETED, "item-deleted")                                                                                    \
+    /**                                                                                                                \
+     * The error is related to rate limitation for the client (version 2)                                              \
+     */                                                                                                                \
+    X(ITEM_RATE_LIMIT, "rate-limit")
 
 #define X(c, s) c,
     LCB_XERRMAP_ATTRIBUTES(X)
@@ -221,7 +225,7 @@ struct Error {
     uint16_t code;
     std::string shortname;
     std::string description;
-    std::set< ErrorAttribute > attributes;
+    std::set<ErrorAttribute> attributes;
     SpecWrapper retry;
 
     Error() : code(-1) {}
@@ -280,7 +284,7 @@ class ErrorMap
   private:
     static const uint32_t MAX_VERSION;
     ErrorMap(const ErrorMap &);
-    typedef std::map< uint16_t, Error > MapType;
+    typedef std::map<uint16_t, Error> MapType;
     MapType errors;
     uint32_t revision{0};
     uint32_t version{0};

package/deps/lcb/src/handler.cc

@@ -157,6 +157,13 @@ lcb_STATUS lcb_map_error(lcb_INSTANCE *instance, int in)
             return LCB_ERR_DURABILITY_AMBIGUOUS;
         case PROTOCOL_BINARY_RESPONSE_LOCKED:
             return LCB_ERR_DOCUMENT_LOCKED;
+        case PROTOCOL_BINARY_RATE_LIMITED_NETWORK_INGRESS:
+        case PROTOCOL_BINARY_RATE_LIMITED_NETWORK_EGRESS:
+        case PROTOCOL_BINARY_RATE_LIMITED_MAX_CONNECTIONS:
+        case PROTOCOL_BINARY_RATE_LIMITED_MAX_COMMANDS:
+            return LCB_ERR_RATE_LIMITED;
+        case PROTOCOL_BINARY_SCOPE_SIZE_LIMIT_EXCEEDED:
+            return LCB_ERR_QUOTA_LIMITED;
         default:
             if (instance != nullptr) {
                 return instance->callbacks.errmap(instance, in);
@@ -269,20 +276,19 @@ void init_resp(lcb_INSTANCE *instance, mc_PIPELINE *pipeline, const MemcachedRes
         resp->ctx.key.assign(key, key_len);
     }
 
-    auto *server = static_cast<lcb::Server *>(pipeline);
+    const auto *server = static_cast<lcb::Server *>(pipeline);
     const lcb_host_t *remote = server->curhost;
     if (remote) {
-        std::stringstream ss;
+        resp->ctx.endpoint.reserve(sizeof(remote->host) + sizeof(remote->port) + 3);
         if (remote->ipv6) {
-            ss << '[';
+            resp->ctx.endpoint.append("[");
         }
-        ss << remote->host;
+        resp->ctx.endpoint.append(remote->host);
         if (remote->ipv6) {
-            ss << ']';
+            resp->ctx.endpoint.append("]");
         }
-        ss << ':';
-        ss << remote->port;
-        resp->ctx.endpoint = ss.str();
+        resp->ctx.endpoint.append(":");
+        resp->ctx.endpoint.append(remote->port);
     }
 }
 
@@ -421,7 +427,7 @@ static void H_get(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse *
 
     void *freeptr = nullptr;
     maybe_decompress(o, response, &resp, &freeptr);
-    LCBTRACE_KV_FINISH(pipeline, request, resp, response->duration());
+    lcb::trace::finish_kv_span(pipeline, request, response);
     TRACE_GET_END(o, request, response, &resp);
     record_kv_op_latency("get", o, request);
     if (request->flags & MCREQ_F_REQEXT) {
@@ -455,7 +461,7 @@ static void H_exists(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedRespons
             resp.seqno = lcb_ntohll(resp.seqno);
         }
     }
-    LCBTRACE_KV_FINISH(pipeline, request, resp, response->duration());
+    lcb::trace::finish_kv_span(pipeline, request, response);
     TRACE_EXISTS_END(root, request, response, &resp);
     record_kv_op_latency("exists", root, request);
     invoke_callback(request, root, &resp, LCB_CALLBACK_EXISTS);
@@ -555,7 +561,7 @@ static void H_subdoc(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedRespons
             handle_error_info(response, resp);
         }
     }
-    LCBTRACE_KV_FINISH(pipeline, request, resp, response->duration());
+    lcb::trace::finish_kv_span(pipeline, request, response);
 
     if (cbtype == LCB_CALLBACK_SDLOOKUP) {
         record_kv_op_latency("lookup_in", o, request);
@@ -689,7 +695,7 @@ static void H_delete(mc_PIPELINE *pipeline, mc_PACKET *packet, MemcachedResponse
     init_resp(root, pipeline, response, packet, immerr, &resp);
     handle_error_info(response, resp);
     handle_mutation_token(root, response, packet, &resp.mt);
-    LCBTRACE_KV_FINISH(pipeline, packet, resp, response->duration());
+    lcb::trace::finish_kv_span(pipeline, packet, response);
     TRACE_REMOVE_END(root, packet, response, &resp);
     record_kv_op_latency("remove", root, packet);
     invoke_callback(packet, root, &resp, LCB_CALLBACK_REMOVE);
@@ -797,7 +803,7 @@ static void H_observe_seqno(mc_PIPELINE *pipeline, mc_PACKET *request, Memcached
         /* Get the server for this command. Note that since this is a successful
          * operation, the server is never a dummy */
     }
-    LCBTRACE_KV_FINISH(pipeline, request, resp, response->duration());
+    lcb::trace::finish_kv_span(pipeline, request, response);
     invoke_callback(request, root, &resp, LCB_CALLBACK_OBSEQNO);
 }
 
@@ -829,7 +835,7 @@ static void H_store(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse
     resp.rflags |= LCB_RESP_F_EXTDATA | LCB_RESP_F_FINAL;
     handle_mutation_token(root, response, request, &resp.mt);
     TRACE_STORE_END(root, request, response, &resp);
-    LCBTRACE_KV_FINISH(pipeline, request, resp, response->duration());
+    lcb::trace::finish_kv_span(pipeline, request, response);
     record_kv_op_latency_store(root, request, &resp);
     if (request->flags & MCREQ_F_REQEXT) {
         request->u_rdata.exdata->procs->handler(pipeline, request, LCB_CALLBACK_STORE, immerr, &resp);
@@ -854,7 +860,7 @@ static void H_arithmetic(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedRes
     }
     resp.rflags |= LCB_RESP_F_FINAL;
     resp.ctx.cas = response->cas();
-    LCBTRACE_KV_FINISH(pipeline, request, resp, response->duration());
+    lcb::trace::finish_kv_span(pipeline, request, response);
     TRACE_ARITHMETIC_END(root, request, response, &resp);
     record_kv_op_latency("arithmetic", root, request);
     invoke_callback(request, root, &resp, LCB_CALLBACK_COUNTER);
@@ -941,7 +947,7 @@ static void H_noop(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse
 {
     lcb_INSTANCE *root = get_instance(pipeline);
     lcb_RESPNOOP resp{};
-    mc_REQDATAEX *exdata = request->u_rdata.exdata;
+    const mc_REQDATAEX *exdata = request->u_rdata.exdata;
 
     make_error(root, &resp, response, immerr, request);
 
@@ -955,7 +961,7 @@ static void H_touch(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse
     init_resp(root, pipeline, response, request, immerr, &resp);
     handle_error_info(response, resp);
     resp.rflags |= LCB_RESP_F_FINAL;
-    LCBTRACE_KV_FINISH(pipeline, request, resp, response->duration());
+    lcb::trace::finish_kv_span(pipeline, request, response);
     TRACE_TOUCH_END(root, request, response, &resp);
     record_kv_op_latency("touch", root, request);
     invoke_callback(request, root, &resp, LCB_CALLBACK_TOUCH);
@@ -968,7 +974,7 @@ static void H_unlock(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedRespons
     init_resp(root, pipeline, response, request, immerr, &resp);
     handle_error_info(response, resp);
     resp.rflags |= LCB_RESP_F_FINAL;
-    LCBTRACE_KV_FINISH(pipeline, request, resp, response->duration());
+    lcb::trace::finish_kv_span(pipeline, request, response);
     TRACE_UNLOCK_END(root, request, response, &resp);
     record_kv_op_latency("unlock", root, request);
     invoke_callback(request, root, &resp, LCB_CALLBACK_UNLOCK);

package/deps/lcb/src/internal.h

@@ -259,7 +259,8 @@ lcb_STATUS lcb_initialize_socket_subsystem(void);
 lcb_STATUS lcb_reinit(lcb_INSTANCE *obj, const char *connstr);
 
 lcb_RETRY_ACTION lcb_kv_should_retry(const lcb_settings *settings, const mc_PACKET *pkt, lcb_STATUS err);
-lcb_RETRY_ACTION lcb_query_should_retry(const lcb_settings *settings, lcb_QUERY_HANDLE *query, lcb_STATUS err);
+lcb_RETRY_ACTION lcb_query_should_retry(const lcb_settings *settings, lcb_QUERY_HANDLE *query, lcb_STATUS err,
+                                        int retry_attribute);
 
 lcb_RESPCALLBACK lcb_find_callback(lcb_INSTANCE *instance, lcb_CALLBACK_TYPE cbtype);
 

package/deps/lcb/src/lcbio/ctx.cc

@@ -136,8 +136,10 @@ void lcbio_ctx_close_ex(lcbio_CTX *ctx, lcbio_CTXCLOSE_cb cb, void *arg, lcbio_C
     }
 
     oldrc = ctx->sock->refcount;
-    lcb_log(LOGARGS(ctx, DEBUG), CTX_LOGFMT "Destroying context. Pending Writes=%d, Entered=%s, Socket Refcount=%d",
-            CTX_LOGID(ctx), (int)ctx->npending, (int)ctx->entered ? "true" : "false", oldrc);
+
+    lcb_log(LOGARGS(ctx, DEBUG),
+            CTX_LOGFMT "Destroying context for SOCK=%016" PRIx64 ". Pending Writes=%d, Entered=%s, Socket Refcount=%d",
+            CTX_LOGID(ctx), ctx->sock->id, (int)ctx->npending, (int)ctx->entered ? "true" : "false", oldrc);
 
     if (cb) {
         int reusable = ctx->npending == 0 &&      /* no pending events */

package/deps/lcb/src/mcserver/mcserver.cc

@@ -341,6 +341,11 @@ static bool is_fastpath_error(uint16_t rc)
         case PROTOCOL_BINARY_RESPONSE_SYNC_WRITE_IN_PROGRESS:
         case PROTOCOL_BINARY_RESPONSE_SYNC_WRITE_AMBIGUOUS:
         case PROTOCOL_BINARY_RESPONSE_LOCKED:
+        case PROTOCOL_BINARY_RATE_LIMITED_NETWORK_INGRESS:
+        case PROTOCOL_BINARY_RATE_LIMITED_NETWORK_EGRESS:
+        case PROTOCOL_BINARY_RATE_LIMITED_MAX_CONNECTIONS:
+        case PROTOCOL_BINARY_RATE_LIMITED_MAX_COMMANDS:
+        case PROTOCOL_BINARY_SCOPE_SIZE_LIMIT_EXCEEDED:
             return true;
         default:
             if (rc >= 0xc0 && rc <= 0xcc) {
@@ -395,10 +400,6 @@ int Server::handle_unknown_error(const mc_PACKET *request, const MemcachedRespon
         newerr = LCB_ERR_TEMPORARY_FAILURE;
     }
 
-    if (err.hasAttribute(errmap::CONSTRAINT_FAILURE)) {
-        newerr = LCB_ERR_CAS_MISMATCH;
-    }
-
     if (err.hasAttribute(errmap::AUTH)) {
         newerr = LCB_ERR_AUTHENTICATION_FAILURE;
     }
@@ -754,6 +755,8 @@ static const char *opcode_name(uint8_t code)
             return "subdoc_get_count";
         case PROTOCOL_BINARY_CMD_GET_ERROR_MAP:
             return "get_error_map";
+        case PROTOCOL_BINARY_CMD_GET_META:
+            return "exists";
         default:
             return "unknown";
     }
@@ -816,7 +819,7 @@ void Server::purge_single(mc_PACKET *pkt, lcb_STATUS err)
         std::string msg(Json::FastWriter().write(info));
         if (msg.size() > 1) {
             lcb_log(LOGARGS(instance, WARN), "Failing command with error %s: %.*s", lcb_strerror_short(err),
-                    (int)(msg.size() - 1), msg.c_str());
+                    (int)msg.size(), msg.c_str());
         }
     } else {
         lcb_log(LOGARGS_T(WARN), LOGFMT "Failing command (pkt=%p, opaque=%lu, opcode=0x%x) with error %s", LOGID_T(),

package/deps/lcb/src/mcserver/negotiate.cc

@@ -185,6 +185,7 @@ class lcb::SessionRequestImpl : public SessionRequest
     SessionInfo *info;
     lcb_settings *settings;
     lcb_host_t host_{};
+    bool expecting_error_map{false};
 };
 
 static void handle_read(lcbio_CTX *ioctx, unsigned)
@@ -316,8 +317,9 @@ SessionRequestImpl::MechStatus SessionRequestImpl::set_chosen_mech(std::string &
                         "PLAIN, but using SCRAM methods is strongly recommended over non-encrypted transports.",
                         LOGID(this));
 #else
-                lcb_log(LOGARGS(this, WARN), LOGFMT "SASL PLAIN authentication is not allowed on non-TLS connections",
-                        LOGID(this));
+                lcb_log(LOGARGS(this, WARN),
+                        LOGFMT "SASL PLAIN authentication is not allowed on non-TLS connections (server supports: %s)",
+                        LOGID(this), mechlist.c_str());
                 return MECH_UNAVAILABLE;
 #endif
             }
@@ -642,15 +644,15 @@ GT_NEXT_PACKET:
             }
 
             if (settings->keypath) {
-                completed = !maybe_select_bucket();
+                completed = !expecting_error_map && !maybe_select_bucket();
             }
             break;
         }
 
         case PROTOCOL_BINARY_CMD_GET_ERROR_MAP: {
+            expecting_error_map = false;
             if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
-                if (!update_errmap(resp)) {
-                }
+                update_errmap(resp);
             } else if (isUnsupported(status)) {
                 lcb_log(LOGARGS(this, DEBUG), LOGFMT "Server does not support GET_ERRMAP (0x%x)", LOGID(this), status);
             } else {
@@ -658,24 +660,46 @@ GT_NEXT_PACKET:
                         status);
                 set_error(LCB_ERR_PROTOCOL_ERROR, "GET_ERRMAP response unexpected", &resp);
             }
+            if (settings->keypath) {
+                completed = !maybe_select_bucket();
+            }
             // Note, there is no explicit state transition here. LIST_MECHS is
             // pipelined after this request.
             break;
         }
 
         case PROTOCOL_BINARY_CMD_SELECT_BUCKET: {
-            if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
-                completed = true;
-                info->selected = true;
-            } else if (status == PROTOCOL_BINARY_RESPONSE_EACCESS) {
-                set_error(LCB_ERR_BUCKET_NOT_FOUND,
-                          "Provided credentials not allowed for bucket or bucket does not exist", &resp);
-            } else if (status == PROTOCOL_BINARY_RESPONSE_KEY_ENOENT) {
-                set_error(LCB_ERR_BUCKET_NOT_FOUND, "Key/Value service is not configured for given node", &resp);
-            } else {
-                lcb_log(LOGARGS(this, ERROR), LOGFMT "Unexpected status 0x%x received for SELECT_BUCKET", LOGID(this),
-                        status);
-                set_error(LCB_ERR_PROTOCOL_ERROR, "Other auth error", &resp);
+            switch (status) {
+                case PROTOCOL_BINARY_RESPONSE_SUCCESS:
+                    completed = true;
+                    info->selected = true;
+                    break;
+
+                case PROTOCOL_BINARY_RESPONSE_EACCESS:
+                    set_error(LCB_ERR_BUCKET_NOT_FOUND,
+                              "Provided credentials not allowed for bucket or bucket does not exist", &resp);
+                    break;
+
+                case PROTOCOL_BINARY_RESPONSE_KEY_ENOENT:
+                    set_error(LCB_ERR_BUCKET_NOT_FOUND, "Key/Value service is not configured for given node", &resp);
+                    break;
+
+                case PROTOCOL_BINARY_RATE_LIMITED_MAX_COMMANDS:
+                case PROTOCOL_BINARY_RATE_LIMITED_MAX_CONNECTIONS:
+                case PROTOCOL_BINARY_RATE_LIMITED_NETWORK_EGRESS:
+                case PROTOCOL_BINARY_RATE_LIMITED_NETWORK_INGRESS:
+                    set_error(LCB_ERR_RATE_LIMITED, "The tenant has reached rate limit", &resp);
+                    break;
+
+                case PROTOCOL_BINARY_SCOPE_SIZE_LIMIT_EXCEEDED:
+                    set_error(LCB_ERR_QUOTA_LIMITED, "The tenant has reached quota limit", &resp);
+                    break;
+
+                default:
+                    lcb_log(LOGARGS(this, ERROR), LOGFMT "Unexpected status 0x%x received for SELECT_BUCKET",
+                            LOGID(this), status);
+                    set_error(LCB_ERR_PROTOCOL_ERROR, "Other auth error", &resp);
+                    break;
             }
             break;
         }
@@ -744,6 +768,7 @@ void SessionRequestImpl::start(lcbio_SOCKET *sock)
     send_hello();
     if (settings->use_errmap) {
         request_errmap();
+        expecting_error_map = true;
     } else {
         lcb_log(LOGARGS(this, TRACE), LOGFMT "GET_ERRORMAP disabled", LOGID(this));
     }

package/deps/lcb/src/n1ql/ixmgmt.cc

@@ -201,8 +201,7 @@ lcb_STATUS dispatch_common(lcb_INSTANCE *instance, const void *cookie, lcb_N1XMG
     Json::Value root;
     root["statement"] = ss;
     string reqbuf = Json::FastWriter().write(root);
-    return dispatch_common<T>(instance, cookie, u_callback, i_callback, reqbuf.c_str(), reqbuf.size() - 1 /*newline*/,
-                              obj);
+    return dispatch_common<T>(instance, cookie, u_callback, i_callback, reqbuf.c_str(), reqbuf.size(), obj);
 }
 
 // Class to back the storage for the actual lcb_IXSPEC without doing too much

package/deps/lcb/src/n1ql/n1ql.cc

@@ -52,10 +52,14 @@ static lcb_RETRY_REASON query_code_to_reason(lcb_STATUS err)
     }
 }
 
-lcb_RETRY_ACTION lcb_query_should_retry(const lcb_settings *settings, lcb_QUERY_HANDLE *query, lcb_STATUS err)
+lcb_RETRY_ACTION lcb_query_should_retry(const lcb_settings *settings, lcb_QUERY_HANDLE *query, lcb_STATUS err,
+                                        int retry_attribute)
 {
     lcb_RETRY_ACTION retry_action{};
     lcb_RETRY_REASON retry_reason = query_code_to_reason(err);
+    if (retry_attribute) {
+        retry_reason = LCB_RETRY_REASON_QUERY_ERROR_RETRYABLE;
+    }
     if (err == LCB_ERR_TIMEOUT) {
         /* We can't exceed a timeout for ETIMEDOUT */
         retry_action.should_retry = 0;