couchbase 3.2.0 → 3.2.4

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;
@@ -175,12 +195,14 @@ lcb_SEARCH_HANDLE_::lcb_SEARCH_HANDLE_(lcb_INSTANCE *instance, void *cookie, con
         root["ctl"]["timeout"] = timeout / 1000; /* us -> ms */
     }
     lcb_cmdhttp_timeout(htcmd, timeout);
+    if (cmd->want_impersonation()) {
+        htcmd->set_header("cb-on-behalf-of", cmd->impostor());
+    }
 
     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/settings.cc

@@ -52,7 +52,7 @@ void lcb_default_settings(lcb_settings *settings)
     settings->compress_min_size = LCB_DEFAULT_COMPRESS_MIN_SIZE;
     settings->compress_min_ratio = (float)LCB_DEFAULT_COMPRESS_MIN_RATIO;
     settings->allocator_factory = rdb_bigalloc_new;
-    settings->detailed_neterr = 0;
+    settings->detailed_neterr = 1;
     settings->refresh_on_hterr = 1;
     settings->sched_implicit_flush = 1;
     settings->fetch_mutation_tokens = 1;

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) {
@@ -618,7 +651,7 @@ void Span::add_tag(const char *name, int copy_key, const char *value, size_t val
     val->t = TAGVAL_STRING;
     val->key.need_free = copy_key;
     if (copy_key) {
-        val->key.p = strdup(name);
+        val->key.p = lcb_strdup(name);
     } else {
         val->key.p = (char *)name;
     }
@@ -649,7 +682,7 @@ void Span::add_tag(const char *name, int copy, uint64_t value)
     val->t = TAGVAL_UINT64;
     val->key.need_free = copy;
     if (copy) {
-        val->key.p = strdup(name);
+        val->key.p = lcb_strdup(name);
     } else {
         val->key.p = (char *)name;
     }
@@ -667,7 +700,7 @@ void Span::add_tag(const char *name, int copy, double value)
     val->t = TAGVAL_DOUBLE;
     val->key.need_free = copy;
     if (copy) {
-        val->key.p = strdup(name);
+        val->key.p = lcb_strdup(name);
     } else {
         val->key.p = (char *)name;
     }
@@ -685,7 +718,7 @@ void Span::add_tag(const char *name, int copy, bool value)
     val->t = TAGVAL_BOOL;
     val->key.need_free = copy;
     if (copy) {
-        val->key.p = strdup(name);
+        val->key.p = lcb_strdup(name);
     } else {
         val->key.p = (char *)name;
     }

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

@@ -29,7 +29,16 @@ LIBCOUCHBASE_API lcbtrace_TRACER *lcbtrace_new(lcb_INSTANCE *instance, uint64_t
             return (new ThresholdLoggingTracer(instance))->wrap();
         case LCBTRACE_F_EXTERNAL: {
             lcbtrace_TRACER *retval = new lcbtrace_TRACER;
+            retval->version = 0;
             retval->flags = LCBTRACE_F_EXTERNAL;
+            retval->cookie = nullptr;
+            retval->destructor = nullptr;
+            retval->v.v0.report = nullptr;
+            retval->v.v1.start_span = nullptr;
+            retval->v.v1.end_span = nullptr;
+            retval->v.v1.destroy_span = nullptr;
+            retval->v.v1.add_tag_string = nullptr;
+            retval->v.v1.add_tag_uint64 = nullptr;
             return retval;
         }
         default:
@@ -86,8 +95,8 @@ void lcb_set_tracer(lcb_INSTANCE *instance, lcbtrace_TRACER *tracer)
 void lcbtrace_span_add_host_and_port(lcbtrace_SPAN *span, lcbio_CONNINFO *info)
 {
     if (span) {
-        lcbtrace_span_add_tag_str_nocopy(span, LCBTRACE_TAG_LOCAL_ADDRESS, info->ep_local2.host);
-        lcbtrace_span_add_tag_str_nocopy(span, LCBTRACE_TAG_LOCAL_PORT, info->ep_local2.port);
+        lcbtrace_span_add_tag_str_nocopy(span, LCBTRACE_TAG_LOCAL_ADDRESS, info->ep_local.host);
+        lcbtrace_span_add_tag_str_nocopy(span, LCBTRACE_TAG_LOCAL_PORT, info->ep_local.port);
         lcbtrace_span_add_tag_str_nocopy(span, LCBTRACE_TAG_PEER_ADDRESS, info->ep_remote.host);
         lcbtrace_span_add_tag_str_nocopy(span, LCBTRACE_TAG_PEER_PORT, info->ep_remote.port);
     }

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

@@ -15,6 +15,12 @@
  *   limitations under the License.
  */
 
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+
+#include <limits>
+
 #include "internal.h"
 
 /**
@@ -171,3 +177,40 @@ const char *lcb_get_tmpdir(void)
     }
 #endif
 }
+
+LCB_INTERNAL_API
+char *lcb_strdup(const char *str)
+{
+    size_t len;
+    char *copy;
+
+    len = strlen(str) + 1;
+    copy = static_cast<char *>(malloc(len));
+    if (copy == nullptr) {
+        return nullptr;
+    }
+    memcpy(copy, str, len);
+
+    return copy;
+}
+
+lcb_STATUS lcb::flexible_framing_extras::encode_impersonate_user(const std::string &username,
+                                                                 std::vector<std::uint8_t> &flexible_framing_extras)
+{
+    auto username_len = username.size();
+    if (username_len > std::numeric_limits<std::uint8_t>::max() + 0xfU) {
+        return LCB_ERR_INVALID_ARGUMENT;
+    }
+    std::uint8_t frame_id = 0x04;
+    if (username_len < 15) {
+        auto frame_size = static_cast<std::uint8_t>(username_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(username_len - 0xfU);
+    }
+    for (const auto byte : username) {
+        flexible_framing_extras.emplace_back(byte);
+    }
+    return LCB_SUCCESS;
+}