couchbase 3.2.2 → 3.2.5

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

@@ -106,6 +106,12 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdunlock_on_behalf_of(lcb_CMDUNLOCK *cmd, const
     return cmd->on_behalf_of(std::string(data, data_len));
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdunlock_on_behalf_of_extra_privilege(lcb_CMDUNLOCK *cmd, const char *privilege,
+                                                                       size_t privilege_len)
+{
+    return cmd->on_behalf_of_add_extra_privilege(std::string(privilege, privilege_len));
+}
+
 static lcb_STATUS unlock_validate(lcb_INSTANCE *instance, const lcb_CMDUNLOCK *cmd)
 {
     if (cmd->key().empty()) {
@@ -137,6 +143,12 @@ static lcb_STATUS unlock_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
         if (err != LCB_SUCCESS) {
             return err;
         }
+        for (const auto &privilege : cmd->extra_privileges()) {
+            err = lcb::flexible_framing_extras::encode_impersonate_users_extra_privilege(privilege, framing_extras);
+            if (err != LCB_SUCCESS) {
+                return err;
+            }
+        }
     }
 
     hdr.request.magic = framing_extras.empty() ? PROTOCOL_BINARY_REQ : PROTOCOL_BINARY_AREQ;
@@ -157,7 +169,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 +178,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,18 @@ 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("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 +127,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 +168,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 +201,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;
@@ -360,7 +359,7 @@ lcbio_pSSLCTX lcbio_ssl_new(const char *tsfile, const char *cafile, const char *
         }
         if (cafile && keyfile) {
             lcb_log(LOGARGS_S(settings, LCB_LOG_DEBUG), "Authenticate with key \"%s\", cert \"%s\"", keyfile, cafile);
-            if (!SSL_CTX_use_certificate_file(ret->ctx, cafile, SSL_FILETYPE_PEM)) {
+            if (!SSL_CTX_use_certificate_chain_file(ret->ctx, cafile)) {
                 *errp = LCB_ERR_SSL_ERROR;
                 goto GT_ERR;
             }

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) {

package/deps/lcb/src/tracing/tracing-internal.h

@@ -26,6 +26,13 @@
 #include <queue>
 #include <map>
 #include <string>
+#include <memory>
+
+LCB_INTERNAL_API
+void lcbtrace_span_add_system_tags(lcbtrace_SPAN *span, const lcb_settings *settings, lcbtrace_THRESHOLDOPTS svc);
+LIBCOUCHBASE_API
+void lcbtrace_span_add_tag_str_nocopy(lcbtrace_SPAN *span, const char *name, const char *value);
+void lcbtrace_span_add_host_and_port(lcbtrace_SPAN *span, lcbio_CONNINFO *info);
 
 namespace lcb
 {
@@ -45,6 +52,7 @@ class Span
         return m_finish - m_start;
     }
 
+    void add_tag(const char *name, const std::string &value);
     void add_tag(const char *name, int copy, const char *value, int copy_value);
     void add_tag(const char *name, int copy_key, const char *value, size_t value_len, int copy_value);
     void add_tag(const char *name, int copy, uint64_t value);
@@ -141,7 +149,7 @@ class ThresholdLoggingTracer
     QueueEntry convert(lcbtrace_SPAN *span);
 
   public:
-    ThresholdLoggingTracer(lcb_INSTANCE *instance);
+    explicit ThresholdLoggingTracer(lcb_INSTANCE *instance);
 
     lcbtrace_TRACER *wrap();
     void add_orphan(lcbtrace_SPAN *span);
@@ -156,108 +164,112 @@ class ThresholdLoggingTracer
     lcb::io::Timer<ThresholdLoggingTracer, &ThresholdLoggingTracer::flush_threshold> m_tflush;
 };
 
-} // namespace trace
-} // namespace lcb
-
-extern "C" {
-#endif /* __cplusplus */
-LCB_INTERNAL_API
-void lcbtrace_span_add_system_tags(lcbtrace_SPAN *span, lcb_settings *settings, lcbtrace_THRESHOLDOPTS svc);
-LCB_INTERNAL_API
-void lcbtrace_span_set_parent(lcbtrace_SPAN *span, lcbtrace_SPAN *parent);
-LCB_INTERNAL_API
-void lcbtrace_span_set_orphaned(lcbtrace_SPAN *span, int val);
-LIBCOUCHBASE_API
-void lcbtrace_span_add_tag_str_nocopy(lcbtrace_SPAN *span, const char *name, const char *value);
-
-const char *dur_level_to_string(lcb_DURABILITY_LEVEL dur_level);
-void lcbtrace_span_add_host_and_port(lcbtrace_SPAN *span, lcbio_CONNINFO *info);
-#ifdef __cplusplus
-#define LCBTRACE_ADD_RETRIES(span, retries)                                                                            \
-    if (span) {                                                                                                        \
-        span->find_outer_or_this()->add_tag(LCBTRACE_TAG_RETRIES, 0, (uint64_t)retries);                               \
+template <typename COMMAND>
+lcbtrace_SPAN *start_kv_span(const lcb_settings *settings, const mc_PACKET *packet, std::shared_ptr<COMMAND> cmd)
+{
+    if (settings == nullptr || settings->tracer == nullptr) {
+        return nullptr;
+    }
+    lcbtrace_SPAN *span;
+    lcbtrace_SPAN *parent_span = cmd->parent_span();
+    if (parent_span != nullptr && parent_span->is_outer() && settings->tracer->flags & LCBTRACE_F_THRESHOLD) {
+        span = parent_span;
+        span->should_finish(false);
+    } else {
+        lcbtrace_REF ref;
+        ref.type = LCBTRACE_REF_CHILD_OF;
+        ref.span = parent_span;
+        bool is_dispatch = (parent_span != nullptr && parent_span->is_outer());
+        span = lcbtrace_span_start((settings)->tracer,
+                                   is_dispatch ? LCBTRACE_OP_DISPATCH_TO_SERVER : cmd->operation_name().c_str(),
+                                   LCBTRACE_NOW, &ref);
+        span->should_finish(true);
+        span->is_outer(!is_dispatch);
     }
+    span->is_dispatch(true);
+    std::string operation_id = std::to_string(packet->opaque);
+    lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_OPERATION_ID, operation_id.c_str());
+    lcbtrace_span_add_system_tags(span, settings, LCBTRACE_THRESHOLD_KV);
+    span->add_tag(LCBTRACE_TAG_SCOPE, cmd->collection().scope());
+    span->add_tag(LCBTRACE_TAG_COLLECTION, cmd->collection().collection());
+    span->add_tag(LCBTRACE_TAG_OPERATION, cmd->operation_name());
+    return span;
+}
 
-// called by lcb_query, etc...  The underlying lcb_http call will fill in the dispatch span tags
-#define LCBTRACE_HTTP_START(settings, opaque, pspan, operation_name, svc, outspan)                                     \
-    LCBTRACE_START(settings, opaque, pspan, operation_name, svc, outspan)
+void finish_kv_span(const mc_PIPELINE *pipeline, const mc_PACKET *request_pkt, const MemcachedResponse *response_pkt);
 
-#define LCBTRACE_KV_START(settings, opaque, cmd, operation_name, outspan)                                              \
-    if (nullptr != (settings)->tracer) {                                                                               \
-        lcbtrace_SPAN *pspan = cmd->parent_span();                                                                     \
-        char opid[20] = {};                                                                                            \
-        snprintf(opid, sizeof(opid), "%p", reinterpret_cast<void *>(opaque));                                          \
-        LCBTRACE_START(settings, opid, pspan, operation_name, LCBTRACE_THRESHOLD_KV, outspan)                          \
+template <typename COMMAND>
+lcbtrace_SPAN *start_kv_span_with_durability(const lcb_settings *settings, const mc_PACKET *packet,
+                                             std::shared_ptr<COMMAND> cmd)
+{
+    lcbtrace_SPAN *span = start_kv_span(settings, packet, cmd);
+    if (span != nullptr && cmd->durability_level() != LCB_DURABILITYLEVEL_NONE) {
+        span->add_tag(LCBTRACE_TAG_DURABILITY, 0, dur_level_to_string(cmd->durability_level()), 0);
     }
+    return span;
+}
 
-// don't create a span if passed an outer parent, if we are the threshold logger,
-// and use its close to determine times, etc...
-#define LCBTRACE_START(settings, opaque, pspan, operation_name, svc, outspan)                                          \
-    if (nullptr != (settings)->tracer) {                                                                               \
-        if (nullptr != pspan && pspan->is_outer() && (settings)->tracer->flags & LCBTRACE_F_THRESHOLD) {               \
-            outspan = pspan;                                                                                           \
-            outspan->should_finish(false);                                                                             \
-        } else {                                                                                                       \
-            lcbtrace_REF ref;                                                                                          \
-            ref.type = LCBTRACE_REF_CHILD_OF;                                                                          \
-            ref.span = pspan;                                                                                          \
-            bool is_dispatch = (pspan && pspan->is_outer());                                                           \
-            outspan =                                                                                                  \
-                lcbtrace_span_start((settings)->tracer, is_dispatch ? LCBTRACE_OP_DISPATCH_TO_SERVER : operation_name, \
-                                    LCBTRACE_NOW, &ref);                                                               \
-            outspan->should_finish(true);                                                                              \
-            outspan->is_outer(!is_dispatch);                                                                           \
-        }                                                                                                              \
-        outspan->is_dispatch(true);                                                                                    \
-        if (opaque) {                                                                                                  \
-            lcbtrace_span_add_tag_str(outspan, LCBTRACE_TAG_OPERATION_ID, opaque);                                     \
-        }                                                                                                              \
-        lcbtrace_span_add_system_tags(outspan, settings, svc);                                                         \
-    } else {                                                                                                           \
-        outspan = nullptr;                                                                                             \
+template <typename COMMAND>
+lcbtrace_SPAN *start_http_span(const lcb_settings *settings, const COMMAND *cmd)
+{
+    if (settings == nullptr || settings->tracer == nullptr) {
+        return nullptr;
+    }
+    lcbtrace_SPAN *span;
+    lcbtrace_SPAN *parent_span = cmd->parent_span();
+    if (parent_span != nullptr && parent_span->is_outer() && settings->tracer->flags & LCBTRACE_F_THRESHOLD) {
+        span = parent_span;
+        span->should_finish(false);
+    } else {
+        lcbtrace_REF ref;
+        ref.type = LCBTRACE_REF_CHILD_OF;
+        ref.span = parent_span;
+        bool is_dispatch = (parent_span != nullptr && parent_span->is_outer());
+        span = lcbtrace_span_start((settings)->tracer,
+                                   is_dispatch ? LCBTRACE_OP_DISPATCH_TO_SERVER : cmd->operation_name().c_str(),
+                                   LCBTRACE_NOW, &ref);
+        span->should_finish(true);
+        span->is_outer(!is_dispatch);
     }
+    span->is_dispatch(true);
+    lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_OPERATION_ID, cmd->client_context_id().c_str());
+    lcbtrace_span_add_system_tags(span, settings, cmd->service());
+    span->add_tag(LCBTRACE_TAG_OPERATION, cmd->operation_name());
+    return span;
+}
 
-#define LCBTRACE_KVSTORE_START(settings, opaque, cmd, operation_name, outspan)                                         \
-    LCBTRACE_KV_START(settings, opaque, cmd, operation_name, outspan)                                                  \
-    if ((settings)->tracer) {                                                                                          \
-        outspan->add_tag(LCBTRACE_TAG_DURABILITY, 0, dur_level_to_string(cmd->durability_level()), 0);                 \
+template <typename COMMAND>
+lcbtrace_SPAN *start_http_span_with_statement(const lcb_settings *settings, const COMMAND *cmd,
+                                              const std::string &statement)
+{
+    lcbtrace_SPAN *span = start_http_span(settings, cmd);
+    if (span != nullptr && !statement.empty()) {
+        span->add_tag(LCBTRACE_TAG_STATEMENT, statement);
     }
+    return span;
+}
 
-#define LCBTRACE_KV_FINISH(pipeline, request, resp, server_duration)                                                   \
-    do {                                                                                                               \
-        lcbtrace_SPAN *dispatch_span__ = MCREQ_PKT_RDATA(request)->span;                                               \
-        if (dispatch_span__) {                                                                                         \
-            dispatch_span__->increment_server(server_duration);                                                        \
-            lcb::Server *server = static_cast<lcb::Server *>(pipeline);                                                \
-            dispatch_span__->find_outer_or_this()->add_tag(LCBTRACE_TAG_RETRIES, 0, (uint64_t)request->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);                                                   \
-            }                                                                                                          \
-        }                                                                                                              \
-    } while (0)
-
-#define LCBTRACE_HTTP_FINISH(span)                                                                                     \
-    if (nullptr != span) {                                                                                             \
-        lcbtrace_span_add_tag_str_nocopy(span, LCBTRACE_TAG_TRANSPORT, "IP.TCP");                                      \
-        if (span->should_finish()) {                                                                                   \
-            lcbtrace_span_finish(span, LCBTRACE_NOW);                                                                  \
-        }                                                                                                              \
-        span = nullptr;                                                                                                \
+template <typename COMMAND>
+void finish_http_span(lcbtrace_SPAN *span, const COMMAND *cmd)
+{
+    if (span != nullptr) {
+        span->find_outer_or_this()->add_tag(LCBTRACE_TAG_RETRIES, 0, (uint64_t)cmd->retries());
+        if (span->should_finish()) {
+            lcbtrace_span_finish(span, LCBTRACE_NOW);
+        }
     }
 }
-#else
-#define LCBTRACE_KVSTORE_START(settings, opaque, cmd, operation_name, outspan)
-#define LCBTRACE_HTTP_START(settings, opaque, pspan, operation_name, svc, outspan)
-#define LCBTRACE_KV_FINISH(pipeline, request, server_duration)
-#define LCBTRACE_HTTP_FINISH(span)
+
+} // namespace trace
+} // namespace lcb
+
+extern "C" {
+#endif /* __cplusplus */
+LCB_INTERNAL_API
+void lcbtrace_span_set_orphaned(lcbtrace_SPAN *span, int val);
+
+const char *dur_level_to_string(lcb_DURABILITY_LEVEL dur_level);
+#ifdef __cplusplus
+}
 #endif /* __cplusplus*/
 #endif /* LCB_TRACING_INTERNAL_H */

package/deps/lcb/src/utilities.cc

@@ -214,3 +214,24 @@ lcb_STATUS lcb::flexible_framing_extras::encode_impersonate_user(const std::stri
     }
     return LCB_SUCCESS;
 }
+
+lcb_STATUS lcb::flexible_framing_extras::encode_impersonate_users_extra_privilege(
+    const std::string &privilege, std::vector<std::uint8_t> &flexible_framing_extras)
+{
+    auto privilege_len = privilege.size();
+    if (privilege_len > std::numeric_limits<std::uint8_t>::max() + 0xfU) {
+        return LCB_ERR_INVALID_ARGUMENT;
+    }
+    std::uint8_t frame_id = 0x06;
+    if (privilege_len < 15) {
+        auto frame_size = static_cast<std::uint8_t>(privilege_len);
+        flexible_framing_extras.emplace_back(frame_id << 4U | frame_size);
+    } else {
+        flexible_framing_extras.emplace_back(frame_id << 4U | 0xfU);
+        flexible_framing_extras.emplace_back(privilege_len - 0xfU);
+    }
+    for (const auto byte : privilege) {
+        flexible_framing_extras.emplace_back(byte);
+    }
+    return LCB_SUCCESS;
+}

package/deps/lcb/src/utilities.h

@@ -29,6 +29,9 @@ namespace lcb
 namespace flexible_framing_extras
 {
 lcb_STATUS encode_impersonate_user(const std::string &username, std::vector<std::uint8_t> &flexible_framing_extras);
+
+lcb_STATUS encode_impersonate_users_extra_privilege(const std::string &privilege,
+                                                    std::vector<std::uint8_t> &flexible_framing_extras);
 } // namespace flexible_framing_extras
 } // namespace lcb
 

package/deps/lcb/src/views/view_handle.cc

@@ -80,8 +80,8 @@ void lcb_VIEW_HANDLE_::invoke_last(lcb_STATUS err)
         if (http_response_ && http_response_->ctx.response_code != 200 && http_response_->ctx.body_len) {
             // chances that were not able to parse response
             Json::Value meta;
-            if (Json::Reader().parse(http_response_->ctx.body, http_response_->ctx.body + http_response_->ctx.body_len,
-                                     meta)) {
+            if (Json::Reader(Json::Features::strictMode())
+                    .parse(http_response_->ctx.body, http_response_->ctx.body + http_response_->ctx.body_len, meta)) {
                 const Json::Value &error = meta["error"];
                 if (error.isString()) {
                     first_error_code_ = error.asString();
@@ -101,7 +101,10 @@ void lcb_VIEW_HANDLE_::invoke_last(lcb_STATUS err)
         resp.ctx.rc = LCB_ERR_VIEW_NOT_FOUND;
     }
 
-    LCBTRACE_HTTP_FINISH(span_);
+    if (span_ != nullptr) {
+        lcb::trace::finish_http_span(span_, this);
+        span_ = nullptr;
+    }
     if (http_request_ != nullptr) {
         http_request_->span = nullptr;
     }
@@ -379,11 +382,16 @@ lcb_VIEW_HANDLE_::lcb_VIEW_HANDLE_(lcb_INSTANCE *instance, void *cookie, const l
             document_queue_->max_pending_response = cmd->max_concurrent_documents();
         }
     }
+    {
+        char buf[32];
+        size_t nbuf = snprintf(buf, sizeof(buf), "%016" PRIx64, lcb_next_rand64());
+        client_context_id_.assign(buf, nbuf);
+    }
 
     lcb_aspend_add(&instance_->pendops, LCB_PENDTYPE_COUNTER, nullptr);
     if (instance->settings->tracer) {
-        LCBTRACE_HTTP_START(instance_->settings, nullptr, cmd->parent_span(), LCBTRACE_TAG_SERVICE_VIEW,
-                            LCBTRACE_THRESHOLD_VIEW, span_);
+        parent_span_ = cmd->parent_span();
+        span_ = lcb::trace::start_http_span(instance_->settings, this);
     }
     last_error_ = request_http(cmd);
 }