couchbase 3.2.3 → 3.2.4

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 {
@@ -664,18 +666,37 @@ GT_NEXT_PACKET:
         }
 
         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 +765,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/query_handle.cc

@@ -99,7 +99,7 @@ bool lcb_QUERY_HANDLE_::parse_meta(const char *row, size_t row_len, lcb_STATUS &
     first_error_code = 0;
 
     Json::Value meta;
-    if (!Json::Reader().parse(row, row + row_len, meta)) {
+    if (!Json::Reader(Json::Features::strictMode()).parse(row, row + row_len, meta)) {
         return false;
     }
     const Json::Value &errors = meta["errors"];
@@ -143,13 +143,15 @@ bool lcb_QUERY_HANDLE_::parse_meta(const char *row, size_t row_len, lcb_STATUS &
                     rc = LCB_ERR_INTERNAL_SERVER_FAILURE;
                     if (!first_error_message.empty()) {
                         std::regex already_exists("Index.+already exists"); /* NOTE: case sensitive */
+                        std::regex not_found("index.+not found");
                         if (std::regex_search(first_error_message, already_exists)) {
                             rc = LCB_ERR_INDEX_EXISTS;
-                        } else {
-                            std::regex not_found("index.+not found");
-                            if (std::regex_search(first_error_message, not_found)) {
-                                rc = LCB_ERR_INDEX_NOT_FOUND;
-                            }
+                        } else if (std::regex_search(first_error_message, not_found)) {
+                            rc = LCB_ERR_INDEX_NOT_FOUND;
+                        } else if (first_error_message.find(
+                                       "Limit for number of indexes that can be created per scope has been reached") !=
+                                   std::string::npos) {
+                            rc = LCB_ERR_QUOTA_LIMITED;
                         }
                     }
                     break;
@@ -166,6 +168,14 @@ bool lcb_QUERY_HANDLE_::parse_meta(const char *row, size_t row_len, lcb_STATUS &
                 case 13014:
                     rc = LCB_ERR_AUTHENTICATION_FAILURE;
                     break;
+
+                case 1191:
+                case 1192:
+                case 1193:
+                case 1194:
+                    rc = LCB_ERR_RATE_LIMITED;
+                    break;
+
                 default:
                     if (first_error_code >= 4000 && first_error_code < 5000) {
                         rc = LCB_ERR_PLANNING_FAILURE;
@@ -195,8 +205,8 @@ void lcb_QUERY_HANDLE_::invoke_row(lcb_RESPQUERY *resp, bool is_last)
         resp->ctx.endpoint = resp->htresp->ctx.endpoint;
         resp->ctx.endpoint_len = resp->htresp->ctx.endpoint_len;
     }
-    resp->ctx.client_context_id = client_context_id.c_str();
-    resp->ctx.client_context_id_len = client_context_id.size();
+    resp->ctx.client_context_id = client_context_id_.c_str();
+    resp->ctx.client_context_id_len = client_context_id_.size();
     resp->ctx.statement = statement_.c_str();
     resp->ctx.statement_len = statement_.size();
 
@@ -213,9 +223,11 @@ void lcb_QUERY_HANDLE_::invoke_row(lcb_RESPQUERY *resp, bool is_last)
             resp->ctx.first_error_message_len = first_error_message.size();
         }
         resp->ctx.first_error_code = first_error_code;
-        LCBTRACE_ADD_RETRIES(span_, retries_);
+        if (span_ != nullptr) {
+            lcb::trace::finish_http_span(span_, this);
+            span_ = nullptr;
+        }
 
-        LCBTRACE_HTTP_FINISH(span_);
         if (http_request_ != nullptr) {
             http_request_->span = nullptr;
         }
@@ -426,7 +438,7 @@ lcb_STATUS lcb_QUERY_HANDLE_::issue_htreq(const std::string &body)
     lcb_log(LOGARGS(this, TRACE),
             LOGFMT "execute query: %.*s, idempotent=%s, timeout=%uus, grace_period=%uus, client_context_id=\"%s\"",
             LOGID(this), (int)body.size(), body.c_str(), idempotent_ ? "true" : "false", timeout,
-            LCBT_SETTING(instance_, n1ql_grace_period), client_context_id.c_str());
+            LCBT_SETTING(instance_, n1ql_grace_period), client_context_id_.c_str());
     return rc;
 }
 
@@ -517,10 +529,10 @@ lcb_QUERY_HANDLE_::lcb_QUERY_HANDLE_(lcb_INSTANCE *obj, void *user_cookie, const
     if (ccid.isNull()) {
         char buf[32];
         size_t nbuf = snprintf(buf, sizeof(buf), "%016" PRIx64, lcb_next_rand64());
-        client_context_id.assign(buf, nbuf);
-        json["client_context_id"] = client_context_id;
+        client_context_id_.assign(buf, nbuf);
+        json["client_context_id"] = client_context_id_;
     } else {
-        client_context_id = ccid.asString();
+        client_context_id_ = ccid.asString();
     }
     if (json.isMember("readonly") && json["readonly"].asBool()) {
         idempotent_ = true;
@@ -554,8 +566,7 @@ lcb_QUERY_HANDLE_::lcb_QUERY_HANDLE_(lcb_INSTANCE *obj, void *user_cookie, const
     }
     if (instance_->settings->tracer) {
         parent_span_ = cmd->parent_span();
-        LCBTRACE_HTTP_START(instance_->settings, client_context_id.c_str(), parent_span_, LCBTRACE_TAG_SERVICE_N1QL,
-                            LCBTRACE_THRESHOLD_QUERY, span_);
+        span_ = lcb::trace::start_http_span_with_statement(instance_->settings, this, statement_);
     }
 }
 

package/deps/lcb/src/n1ql/query_handle.hh

@@ -246,6 +246,32 @@ struct lcb_QUERY_HANDLE_ : lcb::jsparse::Parser::Actions {
         return LCB_SUCCESS;
     }
 
+    static lcbtrace_THRESHOLDOPTS service()
+    {
+        return LCBTRACE_THRESHOLD_QUERY;
+    }
+
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_QUERY;
+        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:
     void on_backoff();
 
@@ -269,7 +295,7 @@ struct lcb_QUERY_HANDLE_ : lcb::jsparse::Parser::Actions {
     Json::Value json;
     /** String of the original statement. Cached here to avoid jsoncpp lookups */
     std::string statement_;
-    std::string client_context_id;
+    std::string client_context_id_;
     std::string first_error_message{};
     uint32_t first_error_code{};
 

package/deps/lcb/src/operations/counter.cc

@@ -237,7 +237,7 @@ static lcb_STATUS counter_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_C
     }
     memcpy(SPAN_BUFFER(&packet->kh_span) + offset, &expiry, sizeof(expiry));
 
-    LCBTRACE_KV_START(instance->settings, packet->opaque, cmd, LCBTRACE_OP_COUNTER, rdata->span);
+    rdata->span = lcb::trace::start_kv_span(instance->settings, packet, cmd);
     TRACE_ARITHMETIC_BEGIN(instance, &hdr, cmd);
     LCB_SCHED_ADD(instance, pipeline, packet);
     return LCB_SUCCESS;

package/deps/lcb/src/operations/exists.cc

@@ -153,7 +153,7 @@ static lcb_STATUS exists_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
 
     hdr.request.opcode = PROTOCOL_BINARY_CMD_GET_META;
     hdr.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
-    hdr.request.bodylen = htonl(ntohs(hdr.request.keylen));
+    hdr.request.bodylen = ntohl(mcreq_get_key_size(&hdr));
     hdr.request.opaque = pkt->opaque;
     hdr.request.cas = 0;
 
@@ -168,7 +168,7 @@ static lcb_STATUS exists_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
         memcpy(SPAN_BUFFER(&pkt->kh_span) + offset, framing_extras.data(), framing_extras.size());
     }
 
-    LCBTRACE_KV_START(instance->settings, pkt->opaque, cmd, LCBTRACE_OP_EXISTS, pkt->u_rdata.reqdata.span);
+    pkt->u_rdata.reqdata.span = lcb::trace::start_kv_span(instance->settings, pkt, cmd);
     LCB_SCHED_ADD(instance, pipeline, pkt)
     TRACE_EXISTS_BEGIN(instance, &hdr, cmd);
     return LCB_SUCCESS;

package/deps/lcb/src/operations/get.cc

@@ -187,7 +187,7 @@ static lcb_STATUS get_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CMDGE
 
     hdr.request.opcode = opcode;
     hdr.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
-    hdr.request.bodylen = htonl(extlen + ffextlen + ntohs(hdr.request.keylen));
+    hdr.request.bodylen = htonl(extlen + ffextlen + mcreq_get_key_size(&hdr));
     hdr.request.opaque = pkt->opaque;
     hdr.request.cas = 0;
 
@@ -209,7 +209,7 @@ static lcb_STATUS get_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CMDGE
         memcpy(SPAN_BUFFER(&pkt->kh_span) + offset, &expiry, sizeof(expiry));
     }
 
-    LCBTRACE_KV_START(instance->settings, pkt->opaque, cmd, LCBTRACE_OP_GET, rdata->span);
+    rdata->span = lcb::trace::start_kv_span(instance->settings, pkt, cmd);
     LCB_SCHED_ADD(instance, pl, pkt)
     TRACE_GET_BEGIN(instance, &hdr, cmd);
     return LCB_SUCCESS;

package/deps/lcb/src/operations/observe.cc

@@ -129,7 +129,7 @@ static void handle_observe_callback(mc_PIPELINE *pl, mc_PACKET *pkt, lcb_CALLBAC
     opc->remaining--;
     if (opc->remaining == 0) {
         TRACE_OBSERVE_END(instance, pkt);
-        LCBTRACE_KV_FINISH(pl, pkt, resp, 0);
+        lcb::trace::finish_kv_span(pl, pkt, nullptr);
         delete opc;
     }
 }

package/deps/lcb/src/operations/remove.cc

@@ -188,7 +188,7 @@ static lcb_STATUS remove_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
     if (!framing_extras.empty()) {
         memcpy(SPAN_BUFFER(&pkt->kh_span) + offset, framing_extras.data(), framing_extras.size());
     }
-    LCBTRACE_KV_START(instance->settings, pkt->opaque, cmd, LCBTRACE_OP_REMOVE, pkt->u_rdata.reqdata.span);
+    pkt->u_rdata.reqdata.span = lcb::trace::start_kv_span(instance->settings, pkt, cmd);
     TRACE_REMOVE_BEGIN(instance, &hdr, cmd);
     LCB_SCHED_ADD(instance, pl, pkt)
     return LCB_SUCCESS;

package/deps/lcb/src/operations/store.cc

@@ -485,7 +485,7 @@ static lcb_STATUS store_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CMD
     if (cmd->is_replace_semantics()) {
         packet->flags |= MCREQ_F_REPLACE_SEMANTICS;
     }
-    LCBTRACE_KVSTORE_START(instance->settings, packet->opaque, cmd, cmd->operation_name(), rdata->span);
+    rdata->span = lcb::trace::start_kv_span_with_durability(instance->settings, packet, cmd);
     LCB_SCHED_ADD(instance, pipeline, packet)
 
     TRACE_STORE_BEGIN(instance, &hdr, cmd);

package/deps/lcb/src/operations/subdoc.cc

@@ -853,8 +853,7 @@ static lcb_STATUS subdoc_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
         MCREQ_PKT_RDATA(pkt)->start +
         cmd->timeout_or_default_in_nanoseconds(LCB_US2NS(LCBT_SETTING(instance, operation_timeout)));
     MCREQ_PKT_RDATA(pkt)->nsubreq = cmd->specs().specs().size();
-    LCBTRACE_KV_START(instance->settings, pkt->opaque, cmd,
-                      ctx.is_mutate() ? LCBTRACE_OP_MUTATEIN : LCBTRACE_OP_LOOKUPIN, MCREQ_PKT_RDATA(pkt)->span);
+    MCREQ_PKT_RDATA(pkt)->span = lcb::trace::start_kv_span(instance->settings, pkt, cmd);
     LCB_SCHED_ADD(instance, pl, pkt)
     return LCB_SUCCESS;
 }

package/deps/lcb/src/operations/touch.cc

@@ -158,7 +158,7 @@ static lcb_STATUS touch_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CMD
     hdr.request.cas = 0;
     hdr.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
     hdr.request.opaque = pkt->opaque;
-    hdr.request.bodylen = htonl(hdr.request.extlen + ffextlen + ntohs(hdr.request.keylen));
+    hdr.request.bodylen = htonl(hdr.request.extlen + ffextlen + mcreq_get_key_size(&hdr));
 
     memcpy(SPAN_BUFFER(&pkt->kh_span), &hdr, sizeof(hdr));
     std::size_t offset = sizeof(hdr);
@@ -174,7 +174,7 @@ static lcb_STATUS touch_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CMD
     pkt->u_rdata.reqdata.deadline =
         pkt->u_rdata.reqdata.start +
         cmd->timeout_or_default_in_nanoseconds(LCB_US2NS(LCBT_SETTING(instance, operation_timeout)));
-    LCBTRACE_KV_START(instance->settings, pkt->opaque, cmd, LCBTRACE_OP_TOUCH, pkt->u_rdata.reqdata.span);
+    pkt->u_rdata.reqdata.span = lcb::trace::start_kv_span(instance->settings, pkt, cmd);
     LCB_SCHED_ADD(instance, pl, pkt);
     TRACE_TOUCH_BEGIN(instance, &hdr, cmd);
     return LCB_SUCCESS;

package/deps/lcb/src/operations/unlock.cc

@@ -157,7 +157,7 @@ static lcb_STATUS unlock_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
 
     hdr.request.opcode = PROTOCOL_BINARY_CMD_UNLOCK_KEY;
     hdr.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
-    hdr.request.bodylen = htonl((lcb_uint32_t)ntohs(hdr.request.keylen));
+    hdr.request.bodylen = htonl(mcreq_get_key_size(&hdr));
     hdr.request.opaque = pkt->opaque;
     hdr.request.cas = lcb_htonll(cmd->cas());
 
@@ -166,7 +166,7 @@ static lcb_STATUS unlock_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
     if (!framing_extras.empty()) {
         memcpy(SPAN_BUFFER(&pkt->kh_span) + offset, framing_extras.data(), framing_extras.size());
     }
-    LCBTRACE_KV_START(instance->settings, pkt->opaque, cmd, LCBTRACE_OP_UNLOCK, rd->span);
+    rd->span = lcb::trace::start_kv_span(instance->settings, pkt, cmd);
     LCB_SCHED_ADD(instance, pl, pkt);
     TRACE_UNLOCK_BEGIN(instance, &hdr, cmd);
     return LCB_SUCCESS;

package/deps/lcb/src/search/search_handle.cc

@@ -23,6 +23,8 @@
 #include "search_handle.hh"
 #include "capi/cmd_http.hh"
 
+#include <regex>
+
 #define LOGFMT "(NR=%p) "
 #define LOGID(req) static_cast<const void *>(req)
 #define LOGARGS(req, lvl) (req)->instance_->settings, "searchh", LCB_LOG_##lvl, __FILE__, __LINE__
@@ -73,7 +75,7 @@ void lcb_SEARCH_HANDLE_::invoke_row(lcb_RESPSEARCH *resp)
     if (callback_) {
         if (resp->rflags & LCB_RESP_F_FINAL) {
             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 &top_error = meta["error"];
                 if (top_error.isString()) {
                     resp->ctx.has_top_level_error = 1;
@@ -92,9 +94,19 @@ void lcb_SEARCH_HANDLE_::invoke_row(lcb_RESPSEARCH *resp)
                     resp->ctx.error_message_len = error_message_.size();
                     if (error_message_.find("QueryBleve parsing") != std::string::npos) {
                         resp->ctx.rc = LCB_ERR_PARSING_FAILURE;
-                    } else if (resp->ctx.http_response_code == 400 &&
-                               error_message_.find("not_found") != std::string::npos) {
-                        resp->ctx.rc = LCB_ERR_INDEX_NOT_FOUND;
+                    } else if (resp->ctx.http_response_code == 400) {
+                        if (error_message_.find("not_found") != std::string::npos) {
+                            resp->ctx.rc = LCB_ERR_INDEX_NOT_FOUND;
+                        } else if (error_message_.find("CreateIndex, Prepare failed, err: num_fts_indexes") !=
+                                   std::string::npos) {
+                            resp->ctx.rc = LCB_ERR_QUOTA_LIMITED;
+                        }
+                    } else if (resp->ctx.http_response_code == 429) {
+                        std::regex rate_limiting_message(
+                            "num_concurrent_requests|num_queries_per_min|ingress_mib_per_min|egress_mib_per_min");
+                        if (std::regex_search(error_message_, rate_limiting_message)) {
+                            resp->ctx.rc = LCB_ERR_RATE_LIMITED;
+                        }
                     }
                 }
             }
@@ -116,7 +128,10 @@ void lcb_SEARCH_HANDLE_::invoke_last()
         resp.nrow = meta.iov_len;
     }
 
-    LCBTRACE_HTTP_FINISH(span_);
+    if (span_ != nullptr) {
+        lcb::trace::finish_http_span(span_, this);
+        span_ = nullptr;
+    }
     if (http_request_ != nullptr) {
         http_request_->span = nullptr;
     }
@@ -154,8 +169,13 @@ lcb_SEARCH_HANDLE_::lcb_SEARCH_HANDLE_(lcb_INSTANCE *instance, void *cookie, con
         return;
     }
     index_name_ = j_ixname.asString();
+    {
+        char buf[32];
+        size_t nbuf = snprintf(buf, sizeof(buf), "%016" PRIx64, lcb_next_rand64());
+        client_context_id_.assign(buf, nbuf);
+    }
     if (instance_->settings->tracer) {
-        span_ = cmd->parent_span();
+        parent_span_ = cmd->parent_span();
     }
 
     std::string url;
@@ -182,8 +202,7 @@ lcb_SEARCH_HANDLE_::lcb_SEARCH_HANDLE_(lcb_INSTANCE *instance, void *cookie, con
     std::string qbody(Json::FastWriter().write(root));
     lcb_cmdhttp_body(htcmd, qbody.c_str(), qbody.size());
 
-    LCBTRACE_HTTP_START(instance_->settings, nullptr, span_, LCBTRACE_TAG_SERVICE_SEARCH, LCBTRACE_THRESHOLD_SEARCH,
-                        span_);
+    span_ = lcb::trace::start_http_span(instance_->settings, this);
     lcb_cmdhttp_parent_span(htcmd, span_);
 
     last_error_ = lcb_http(instance_, this, htcmd);

package/deps/lcb/src/search/search_handle.hh

@@ -115,6 +115,32 @@ struct lcb_SEARCH_HANDLE_ : lcb::jsparse::Parser::Actions {
         }
     }
 
+    static lcbtrace_THRESHOLDOPTS service()
+    {
+        return LCBTRACE_THRESHOLD_SEARCH;
+    }
+
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_SEARCH;
+        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};
@@ -124,9 +150,12 @@ struct lcb_SEARCH_HANDLE_ : lcb::jsparse::Parser::Actions {
     lcb_INSTANCE *instance_{nullptr};
     size_t rows_number_{0};
     lcb_STATUS last_error_{LCB_SUCCESS};
+    lcbtrace_SPAN *parent_span_{nullptr};
     lcbtrace_SPAN *span_{nullptr};
     std::string index_name_;
     std::string error_message_;
+    std::string client_context_id_{};
+    int retries_{0};
 };
 
 #endif // LIBCOUCHBASE_SEARCH_HANDLE_HH

package/deps/lcb/src/ssl/ssl_common.c

@@ -219,7 +219,6 @@ int iotssl_maybe_error(lcbio_XSSL *xs, int rv)
  ******************************************************************************/
 static void log_callback(const SSL *ssl, int where, int ret)
 {
-    const char *retstr;
     int should_log = 0;
     lcbio_SOCKET *sock = SSL_get_app_data(ssl);
     /* Ignore low-level SSL stuff */
@@ -238,9 +237,9 @@ static void log_callback(const SSL *ssl, int where, int ret)
         return;
     }
 
-    retstr = SSL_alert_type_string(ret);
-    lcb_log(LOGARGS(ssl, LCB_LOG_TRACE), "sock=%p: ST(0x%x). %s. R(0x%x)%s", (void *)sock, where,
-            SSL_state_string_long(ssl), ret, retstr);
+    lcb_log(LOGARGS(ssl, LCB_LOG_TRACE), "<%s:%s> sock=%p: ST(0x%x). %s. R(0x%x) %s (%s)",
+            sock->info ? sock->info->ep_remote.host : "", sock->info ? sock->info->ep_remote.port : "", (void *)sock,
+            where, SSL_state_string_long(ssl), ret, SSL_alert_type_string_long(ret), SSL_alert_desc_string_long(ret));
 
     if (where == SSL_CB_HANDSHAKE_DONE) {
         lcb_log(LOGARGS(ssl, LCB_LOG_DEBUG), "sock=%p. Using SSL version %s. Cipher=%s", (void *)sock,
@@ -311,11 +310,11 @@ lcbio_pSSLCTX lcbio_ssl_new(const char *tsfile, const char *cafile, const char *
         "MD5:RC4-SHA:RC4-MD5:RC4-MD5:EDH-RSA-DES-CBC-SHA:EDH-DSS-DES-CBC-SHA:DES-CBC-SHA:DES-CBC-MD5:EXP-EDH-RSA-DES-"
         "CBC-SHA:EXP-EDH-DSS-DES-CBC-SHA:EXP-DES-CBC-SHA:EXP-RC2-CBC-MD5:EXP-RC2-CBC-MD5:EXP-RC4-MD5:EXP-RC4-MD5";
 
-    const char* cipher_list = getenv("LCB_SSL_CIPHER_LIST");
+    const char *cipher_list = getenv("LCB_SSL_CIPHER_LIST");
 #ifdef HAVE_CIPHERSUITES
-    const char* ciphersuites = getenv("LCB_SSL_CIPHERSUITES");
+    const char *ciphersuites = getenv("LCB_SSL_CIPHERSUITES");
 #endif
-    const char* minimum_tls = getenv("LCB_SSL_MINIMUM_TLS");
+    const char *minimum_tls = getenv("LCB_SSL_MINIMUM_TLS");
 
     if (!cipher_list) {
         cipher_list = default_ssl_cipher_list;

package/deps/lcb/src/tracing/span.cc

@@ -21,6 +21,8 @@
 #include <sys/timeb.h>
 #endif
 
+#include "n1ql/query_handle.hh"
+
 typedef enum { TAGVAL_STRING, TAGVAL_UINT64, TAGVAL_DOUBLE, TAGVAL_BOOL } tag_type;
 typedef struct tag_value {
     sllist_node slnode;
@@ -129,7 +131,7 @@ void lcbtrace_span_add_tag_bool(lcbtrace_SPAN *span, const char *name, int value
 }
 
 LCB_INTERNAL_API
-void lcbtrace_span_add_system_tags(lcbtrace_SPAN *span, lcb_settings *settings, lcbtrace_THRESHOLDOPTS svc)
+void lcbtrace_span_add_system_tags(lcbtrace_SPAN *span, const lcb_settings *settings, lcbtrace_THRESHOLDOPTS svc)
 {
     if (!span) {
         return;
@@ -138,6 +140,7 @@ void lcbtrace_span_add_system_tags(lcbtrace_SPAN *span, lcb_settings *settings,
         span->service(svc);
     }
     span->add_tag(LCBTRACE_TAG_SYSTEM, 0, "couchbase", 0);
+    span->add_tag(LCBTRACE_TAG_TRANSPORT, 0, "IP.TCP", 0);
     std::string client_string(LCB_CLIENT_ID);
     if (settings->client_string) {
         client_string += " ";
@@ -158,15 +161,6 @@ lcbtrace_SPAN *lcbtrace_span_get_parent(lcbtrace_SPAN *span)
     return span->m_parent;
 }
 
-LCB_INTERNAL_API
-void lcbtrace_span_set_parent(lcbtrace_SPAN *span, lcbtrace_SPAN *parent)
-{
-    if (!span) {
-        return;
-    }
-    span->m_parent = parent;
-}
-
 LIBCOUCHBASE_API
 uint64_t lcbtrace_span_get_start_ts(lcbtrace_SPAN *span)
 {
@@ -412,6 +406,38 @@ LIBCOUCHBASE_API lcb_STATUS lcbtrace_span_get_is_encode(lcbtrace_SPAN *span, int
     return LCB_SUCCESS;
 }
 
+namespace lcb
+{
+namespace trace
+{
+void finish_kv_span(const mc_PIPELINE *pipeline, const mc_PACKET *request_pkt,
+                    const lcb::MemcachedResponse *response_pkt)
+{
+    lcbtrace_SPAN *dispatch_span = MCREQ_PKT_RDATA(request_pkt)->span;
+    if (dispatch_span) {
+        if (response_pkt != nullptr) {
+            dispatch_span->increment_server(response_pkt->duration());
+        }
+        auto *server = static_cast<const lcb::Server *>(pipeline);
+        dispatch_span->find_outer_or_this()->add_tag(LCBTRACE_TAG_RETRIES, 0, (uint64_t)request_pkt->retries);
+        lcbtrace_span_add_tag_str_nocopy(dispatch_span, LCBTRACE_TAG_TRANSPORT, "IP.TCP");
+        lcbio_CTX *ctx = server->connctx;
+        if (ctx) {
+            char local_id[34] = {};
+            snprintf(local_id, sizeof(local_id), "%016" PRIx64 "/%016" PRIx64, (uint64_t)server->get_settings()->iid,
+                     (uint64_t)ctx->sock->id);
+            lcbtrace_span_add_tag_str(dispatch_span, LCBTRACE_TAG_LOCAL_ID, local_id);
+            lcbtrace_span_add_host_and_port(dispatch_span, ctx->sock->info);
+        }
+        if (dispatch_span->should_finish()) {
+            lcbtrace_span_finish(dispatch_span, LCBTRACE_NOW);
+        }
+    }
+}
+
+} // namespace trace
+} // namespace lcb
+
 using namespace lcb::trace;
 
 Span::Span(lcbtrace_TRACER *tracer, const char *opname, uint64_t start, lcbtrace_REF_TYPE ref, lcbtrace_SPAN *other,
@@ -601,6 +627,13 @@ void Span::add_tag(const char *name, int copy_key, const char *value, int copy_v
     }
 }
 
+void Span::add_tag(const char *name, const std::string &value)
+{
+    if (name != nullptr && !value.empty()) {
+        add_tag(name, 0, value.c_str(), value.size(), 1);
+    }
+}
+
 void Span::add_tag(const char *name, int copy_key, const char *value, size_t value_len, int copy_value)
 {
     if (nullptr != m_extspan && nullptr != m_tracer) {