couchbase 3.2.3 → 3.2.4

package/deps/lcb/packaging/deb/control

@@ -6,7 +6,7 @@ Standards-Version: 3.9.2
 Section: libs
 Homepage: http://www.couchbase.com/develop/c/current
 Vcs-Browser: https://github.com/couchbase/libcouchbase
-Vcs-Git: git://github.com/couchbase/libcouchbase.git
+Vcs-Git: https://github.com/couchbase/libcouchbase.git
 
 Package: libcouchbase3-libevent
 Architecture: any

package/deps/lcb/src/analytics/analytics_handle.cc

@@ -225,7 +225,7 @@ lcb_ANALYTICS_HANDLE_::lcb_ANALYTICS_HANDLE_(lcb_INSTANCE *obj, void *user_cooki
     query_params_ = Json::FastWriter().write(cmd->root());
 
     if (instance_->settings->tracer) {
-        span_ = cmd->parent_span();
+        parent_span_ = cmd->parent_span();
     }
 
     if (ingest_options().method != LCB_INGEST_METHOD_NONE) {
@@ -284,8 +284,7 @@ lcb_STATUS lcb_ANALYTICS_HANDLE_::issue_htreq(const std::string &body)
         htcmd->set_header("cb-on-behalf-of", impostor_);
     }
 
-    LCBTRACE_HTTP_START(instance_->settings, client_context_id_.c_str(), span_, LCBTRACE_TAG_SERVICE_ANALYTICS,
-                        LCBTRACE_THRESHOLD_ANALYTICS, span_);
+    span_ = lcb::trace::start_http_span_with_statement(instance_->settings, this, statement_);
     lcb_cmdhttp_parent_span(htcmd, span_);
 
     lcb_STATUS rc = lcb_http(instance_, this, htcmd);
@@ -394,7 +393,7 @@ void lcb_ANALYTICS_HANDLE_::invoke_row(lcb_RESPANALYTICS *resp, bool is_last)
             resp->rflags |= LCB_RESP_F_EXTDATA;
         }
         Json::Value meta;
-        if (Json::Reader().parse(resp->row, resp->row + resp->nrow, meta)) {
+        if (Json::Reader(Json::Features::strictMode()).parse(resp->row, resp->row + resp->nrow, meta)) {
             const Json::Value &errors = meta["errors"];
             if (errors.isArray() && !errors.empty()) {
                 const Json::Value &err = errors[0];
@@ -456,7 +455,10 @@ void lcb_ANALYTICS_HANDLE_::invoke_row(lcb_RESPANALYTICS *resp, bool is_last)
             }
         }
 
-        LCBTRACE_HTTP_FINISH(span_);
+        if (span_ != nullptr) {
+            lcb::trace::finish_http_span(span_, this);
+            span_ = nullptr;
+        }
         if (http_request_ != nullptr) {
             http_request_->span = nullptr;
         }

package/deps/lcb/src/analytics/analytics_handle.hh

@@ -208,6 +208,32 @@ struct lcb_ANALYTICS_HANDLE_ : lcb::jsparse::Parser::Actions {
         return last_error_;
     }
 
+    static lcbtrace_THRESHOLDOPTS service()
+    {
+        return LCBTRACE_THRESHOLD_ANALYTICS;
+    }
+
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_ANALYTICS;
+        return name;
+    }
+
+    lcbtrace_SPAN *parent_span() const
+    {
+        return parent_span_;
+    }
+
+    const std::string &client_context_id() const
+    {
+        return client_context_id_;
+    }
+
+    int retries() const
+    {
+        return retries_;
+    }
+
   private:
     const lcb_RESPHTTP *http_response_{nullptr};
     lcb_HTTP_HANDLE *http_request_{nullptr};
@@ -219,6 +245,7 @@ struct lcb_ANALYTICS_HANDLE_ : lcb::jsparse::Parser::Actions {
     lcb_U32 timeout_{0};
     // How many rows were received. Used to avoid parsing the meta
     size_t rows_number_{0};
+    int retries_{0};
 
     /** Request body as received from the application */
     Json::Value json{};
@@ -240,6 +267,7 @@ struct lcb_ANALYTICS_HANDLE_ : lcb::jsparse::Parser::Actions {
     lcb::docreq::Queue *document_queue_{nullptr};
     unsigned refcount{1};
 
+    lcbtrace_SPAN *parent_span_{nullptr};
     lcbtrace_SPAN *span_{nullptr};
     std::string impostor_{};
 };

package/deps/lcb/src/capi/cmd_counter.hh

@@ -30,6 +30,12 @@
  */
 struct lcb_CMDCOUNTER_ {
   public:
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_COUNTER;
+        return name;
+    }
+
     lcb_STATUS expiry(std::uint32_t expiry)
     {
         if (!initialize_if_does_not_exist_) {

package/deps/lcb/src/capi/cmd_exists.hh

@@ -28,6 +28,12 @@
  * @private
  */
 struct lcb_CMDEXISTS_ {
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_EXISTS;
+        return name;
+    }
+
     lcb_STATUS key(std::string key)
     {
         key_ = std::move(key);

package/deps/lcb/src/capi/cmd_get.hh

@@ -34,6 +34,11 @@ enum class get_mode {
  * @private
  */
 struct lcb_CMDGET_ {
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_GET;
+        return name;
+    }
 
     lcb_STATUS with_touch(std::uint32_t expiry)
     {

package/deps/lcb/src/capi/cmd_get_replica.hh

@@ -36,6 +36,12 @@ enum class get_replica_mode {
  * @private
  */
 struct lcb_CMDGETREPLICA_ {
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_GET_FROM_REPLICA;
+        return name;
+    }
+
     lcb_STATUS mode(get_replica_mode mode)
     {
         mode_ = mode;

package/deps/lcb/src/capi/cmd_remove.hh

@@ -28,6 +28,12 @@
  * @private
  */
 struct lcb_CMDREMOVE_ {
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_REMOVE;
+        return name;
+    }
+
     lcb_STATUS cas(std::uint64_t cas)
     {
         cas_ = cas;

package/deps/lcb/src/capi/cmd_search.hh

@@ -70,6 +70,12 @@ struct lcb_RESPSEARCH_ {
  * @private
  */
 struct lcb_CMDSEARCH_ {
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_SEARCH;
+        return name;
+    }
+
     bool has_callback() const
     {
         return callback_ != nullptr;

package/deps/lcb/src/capi/cmd_store.hh

@@ -35,6 +35,16 @@ enum class durability_mode {
  * @private
  */
 struct lcb_CMDSTORE_ {
+    const std::string &operation_name() const
+    {
+        static std::map<int, std::string> names{
+            {LCB_STORE_UPSERT, LCBTRACE_OP_UPSERT}, {LCB_STORE_REPLACE, LCBTRACE_OP_REPLACE},
+            {LCB_STORE_APPEND, LCBTRACE_OP_APPEND}, {LCB_STORE_PREPEND, LCBTRACE_OP_PREPEND},
+            {LCB_STORE_INSERT, LCBTRACE_OP_INSERT},
+        };
+        return names[operation_];
+    }
+
     lcb_STATUS operation(lcb_STORE_OPERATION operation)
     {
         operation_ = operation;
@@ -123,24 +133,6 @@ struct lcb_CMDSTORE_ {
         return false;
     }
 
-    const char *operation_name() const
-    {
-        switch (operation_) {
-            case LCB_STORE_UPSERT:
-                return LCBTRACE_OP_UPSERT;
-            case LCB_STORE_REPLACE:
-                return LCBTRACE_OP_REPLACE;
-            case LCB_STORE_APPEND:
-                return LCBTRACE_OP_APPEND;
-            case LCB_STORE_PREPEND:
-                return LCBTRACE_OP_PREPEND;
-            case LCB_STORE_INSERT:
-                return LCBTRACE_OP_INSERT;
-        }
-        lcb_assert(false && "unknown operation name");
-        return "unknown";
-    }
-
     lcb_STATUS flags(std::uint32_t flags)
     {
         if (operation_ == LCB_STORE_APPEND || operation_ == LCB_STORE_PREPEND) {
@@ -245,13 +237,16 @@ struct lcb_CMDSTORE_ {
 
     lcb_STATUS value(const lcb_IOV *iov, std::size_t iov_len)
     {
-        std::stringstream ss;
+        std::size_t total_size = 0;
+        for (std::size_t i = 0; i < iov_len; ++i) {
+            total_size += iov[i].iov_len;
+        }
+        value_.reserve(total_size);
         for (std::size_t i = 0; i < iov_len; ++i) {
             if (iov[i].iov_len > 0 && iov[i].iov_base != nullptr) {
-                ss << std::string(static_cast<const char *>(iov[i].iov_base), iov[i].iov_len);
+                value_.append(static_cast<const char *>(iov[i].iov_base), iov[i].iov_len);
             }
         }
-        value_ = ss.str();
         return LCB_SUCCESS;
     }
 

package/deps/lcb/src/capi/cmd_subdoc.hh

@@ -114,6 +114,12 @@ struct subdoc_spec_options {
  * This structure is provided in an array to the lcb_CMDSUBDOC::specs field.
  */
 struct subdoc_spec {
+    bool is_lookup() const
+    {
+        return opcode_ == subdoc_opcode::get || opcode_ == subdoc_opcode::get_count ||
+               opcode_ == subdoc_opcode::get_fulldoc || opcode_ == subdoc_opcode::exist;
+    }
+
     subdoc_opcode opcode() const
     {
         return opcode_;
@@ -216,11 +222,23 @@ struct lcb_SUBDOCSPECS_ {
         return specs_;
     }
 
+    bool is_lookup() const
+    {
+        return specs_.empty() || specs_[0].is_lookup();
+    }
+
   private:
     std::vector<subdoc_spec> specs_{};
 };
 
 struct lcb_CMDSUBDOC_ {
+    const std::string &operation_name() const
+    {
+        static std::string lookup_in_name = LCBTRACE_OP_LOOKUPIN;
+        static std::string mutate_in_name = LCBTRACE_OP_MUTATEIN;
+        return specs_.is_lookup() ? lookup_in_name : mutate_in_name;
+    }
+
     const subdoc_options &options() const
     {
         return options_;

package/deps/lcb/src/capi/cmd_touch.hh

@@ -28,6 +28,12 @@
  * @private
  */
 struct lcb_CMDTOUCH_ {
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_TOUCH;
+        return name;
+    }
+
     lcb_STATUS expiry(std::uint32_t expiry)
     {
         expiry_ = expiry;

package/deps/lcb/src/capi/cmd_unlock.hh

@@ -28,6 +28,12 @@
  * @private
  */
 struct lcb_CMDUNLOCK_ {
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_UNLOCK;
+        return name;
+    }
+
     lcb_STATUS cas(std::uint64_t cas)
     {
         if (cas == 0) {

package/deps/lcb/src/capi/cmd_view.hh

@@ -47,6 +47,12 @@ struct lcb_VIEW_ERROR_CONTEXT_ {
 
 /** @private */
 struct lcb_CMDVIEW_ {
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_VIEW;
+        return name;
+    }
+
     bool view_or_design_document_empty() const
     {
         return view_name_.empty() || design_document_name_.empty();

package/deps/lcb/src/capi/collection_qualifier.hh

@@ -135,8 +135,8 @@ struct collection_qualifier {
         return true;
     }
 
-    std::string scope_{};
-    std::string collection_{};
+    std::string scope_{"_default"};
+    std::string collection_{"_default"};
     std::string spec_{};
     std::uint32_t resolved_collection_id_{0};
     bool resolved_{false};

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/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(),