couchbase 3.2.2 → 3.2.5

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

@@ -95,32 +95,52 @@ static void prepare_rowcb(lcb_INSTANCE *instance, int, const lcb_RESPQUERY *row)
 
 bool lcb_QUERY_HANDLE_::parse_meta(const char *row, size_t row_len, lcb_STATUS &rc)
 {
-    first_error_message.clear();
-    first_error_code = 0;
+    first_error.message.clear();
+    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"];
     if (errors.isArray() && !errors.empty()) {
         const Json::Value &err = errors[0];
+        if (err.isMember("retry") && err["retry"].isBool()) {
+            first_error.retry = err["retry"].asBool();
+        }
+        if (err.isMember("reason") && err["reason"].isObject()) {
+            const Json::Value &reason = err["reason"];
+            if (reason.isMember("code") && reason["code"].isNumeric()) {
+                first_error.reason_code = reason["code"].asInt();
+            }
+        }
         const Json::Value &msg = err["msg"];
         if (msg.isString()) {
-            first_error_message = msg.asString();
+            first_error.message = msg.asString();
         }
         const Json::Value &code = err["code"];
         if (code.isNumeric()) {
-            first_error_code = code.asUInt();
-            switch (first_error_code) {
+            first_error.code = code.asUInt();
+            switch (first_error.code) {
                 case 3000:
                     rc = LCB_ERR_PARSING_FAILURE;
                     break;
                 case 12009:
                     rc = LCB_ERR_DML_FAILURE;
-                    if (first_error_message.find("CAS mismatch") != std::string::npos) {
+                    if (first_error.message.find("CAS mismatch") != std::string::npos) {
                         rc = LCB_ERR_CAS_MISMATCH;
                     }
+                    switch (first_error.reason_code) {
+                        case 12033:
+                            rc = LCB_ERR_CAS_MISMATCH;
+                            break;
+                        case 17014:
+                            rc = LCB_ERR_DOCUMENT_NOT_FOUND;
+                            break;
+                        case 17012:
+                            rc = LCB_ERR_DOCUMENT_EXISTS;
+                            break;
+                    }
                     break;
                 case 4040:
                 case 4050:
@@ -132,29 +152,34 @@ bool lcb_QUERY_HANDLE_::parse_meta(const char *row, size_t row_len, lcb_STATUS &
                     break;
                 case 4300:
                     rc = LCB_ERR_PLANNING_FAILURE;
-                    if (!first_error_message.empty()) {
+                    if (!first_error.message.empty()) {
                         std::regex already_exists("index.+already exists");
-                        if (std::regex_search(first_error_message, already_exists)) {
+                        if (std::regex_search(first_error.message, already_exists)) {
                             rc = LCB_ERR_INDEX_EXISTS;
                         }
                     }
                     break;
                 case 5000:
                     rc = LCB_ERR_INTERNAL_SERVER_FAILURE;
-                    if (!first_error_message.empty()) {
+                    if (!first_error.message.empty()) {
                         std::regex already_exists("Index.+already exists"); /* NOTE: case sensitive */
-                        if (std::regex_search(first_error_message, already_exists)) {
+                        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;
-                case 12004:
                 case 12016:
+                    /* see MB-50643 */
+                    first_error.retry = false;
+                    /* fallthrough */
+                case 12004:
                     rc = LCB_ERR_INDEX_NOT_FOUND;
                     break;
                 case 12003:
@@ -166,15 +191,23 @@ 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) {
+                    if (first_error.code >= 4000 && first_error.code < 5000) {
                         rc = LCB_ERR_PLANNING_FAILURE;
-                    } else if (first_error_code >= 5000 && first_error_code < 6000) {
+                    } else if (first_error.code >= 5000 && first_error.code < 6000) {
                         rc = LCB_ERR_INTERNAL_SERVER_FAILURE;
-                    } else if (first_error_code >= 10000 && first_error_code < 11000) {
+                    } else if (first_error.code >= 10000 && first_error.code < 11000) {
                         rc = LCB_ERR_AUTHENTICATION_FAILURE;
-                    } else if ((first_error_code >= 12000 && first_error_code < 13000) ||
-                               (first_error_code >= 14000 && first_error_code < 15000)) {
+                    } else if ((first_error.code >= 12000 && first_error.code < 13000) ||
+                               (first_error.code >= 14000 && first_error.code < 15000)) {
                         rc = LCB_ERR_INDEX_FAILURE;
                     }
                     break;
@@ -195,8 +228,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();
 
@@ -208,14 +241,18 @@ void lcb_QUERY_HANDLE_::invoke_row(lcb_RESPQUERY *resp, bool is_last)
         resp->row = static_cast<const char *>(meta_buf.iov_base);
         resp->nrow = meta_buf.iov_len;
         parse_meta(resp->row, resp->nrow, resp->ctx.rc);
-        if (!first_error_message.empty()) {
-            resp->ctx.first_error_message = first_error_message.c_str();
-            resp->ctx.first_error_message_len = first_error_message.size();
+        resp->ctx.error_response_body = resp->row;
+        resp->ctx.error_response_body_len = resp->nrow;
+        if (!first_error.message.empty()) {
+            resp->ctx.first_error_message = first_error.message.c_str();
+            resp->ctx.first_error_message_len = first_error.message.size();
+        }
+        resp->ctx.first_error_code = first_error.code;
+        if (span_ != nullptr) {
+            lcb::trace::finish_http_span(span_, this);
+            span_ = nullptr;
         }
-        resp->ctx.first_error_code = first_error_code;
-        LCBTRACE_ADD_RETRIES(span_, retries_);
 
-        LCBTRACE_HTTP_FINISH(span_);
         if (http_request_ != nullptr) {
             http_request_->span = nullptr;
         }
@@ -346,27 +383,27 @@ lcb_RETRY_ACTION lcb_QUERY_HANDLE_::has_retriable_error(lcb_STATUS &rc)
     const uint32_t default_backoff = 100 /* ms */;
     if (rc == LCB_ERR_PREPARED_STATEMENT_FAILURE) {
         lcb_log(LOGARGS(this, TRACE), LOGFMT "Will retry request. rc: %s, code: %d, msg: %s", LOGID(this),
-                lcb_strerror_short(rc), first_error_code, first_error_message.c_str());
+                lcb_strerror_short(rc), first_error.code, first_error.message.c_str());
         return {1, default_backoff};
     }
-    if (first_error_code == 13014 &&
+    if (first_error.code == 13014 &&
         LCBT_SETTING(instance_, auth)->mode() == LCBAUTH_MODE_DYNAMIC) { // datastore.couchbase.insufficient_credentials
         auto result = request_credentials(LCBAUTH_REASON_AUTHENTICATION_FAILURE);
         bool credentials_found = result == LCBAUTH_RESULT_OK;
         lcb_log(LOGARGS(this, TRACE),
                 LOGFMT "Invalidate credentials and retry request. creds: %s, rc: %s, code: %d, msg: %s", LOGID(this),
-                credentials_found ? "ok" : "not_found", lcb_strerror_short(rc), first_error_code,
-                first_error_message.c_str());
+                credentials_found ? "ok" : "not_found", lcb_strerror_short(rc), first_error.code,
+                first_error.message.c_str());
         return {credentials_found, default_backoff};
     }
-    if (!first_error_message.empty()) {
+    if (!first_error.message.empty()) {
         for (const auto &magic_string : wtf_magic_strings) {
-            if (first_error_message.find(magic_string) != std::string::npos) {
+            if (first_error.message.find(magic_string) != std::string::npos) {
                 lcb_log(LOGARGS(this, TRACE),
                         LOGFMT
                         "Special error message detected. Will retry request. rc: %s (update to %s), code: %d, msg: %s",
                         LOGID(this), lcb_strerror_short(rc), lcb_strerror_short(LCB_ERR_PREPARED_STATEMENT_FAILURE),
-                        first_error_code, first_error_message.c_str());
+                        first_error.code, first_error.message.c_str());
                 rc = LCB_ERR_PREPARED_STATEMENT_FAILURE;
                 return {1, default_backoff};
             }
@@ -376,7 +413,7 @@ lcb_RETRY_ACTION lcb_QUERY_HANDLE_::has_retriable_error(lcb_STATUS &rc)
     if (rc == LCB_SUCCESS) {
         return {0, 0};
     }
-    return lcb_query_should_retry(instance_->settings, this, rc);
+    return lcb_query_should_retry(instance_->settings, this, rc, first_error.retry);
 }
 
 lcb_STATUS lcb_QUERY_HANDLE_::issue_htreq(const std::string &body)
@@ -426,7 +463,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 +554,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 +591,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

@@ -27,6 +27,19 @@
 #include "capi/cmd_query.hh"
 #include "query_cache.hh"
 
+/**
+ * @private
+ */
+namespace lcb
+{
+struct query_error {
+    std::string message{};
+    uint32_t code{};
+    bool retry{false};
+    uint32_t reason_code{0};
+};
+} // namespace lcb
+
 /**
  * @private
  */
@@ -246,6 +259,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,9 +308,8 @@ 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 first_error_message{};
-    uint32_t first_error_code{};
+    std::string client_context_id_;
+    lcb::query_error first_error{};
 
     /** Whether we're retrying this */
     int retries_{0};

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

@@ -141,6 +141,12 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdcounter_on_behalf_of(lcb_CMDCOUNTER *cmd, con
     return cmd->on_behalf_of(std::string(data, data_len));
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdcounter_on_behalf_of_extra_privilege(lcb_CMDCOUNTER *cmd, const char *privilege,
+                                                                        size_t privilege_len)
+{
+    return cmd->on_behalf_of_add_extra_privilege(std::string(privilege, privilege_len));
+}
+
 static lcb_STATUS counter_validate(lcb_INSTANCE *instance, const lcb_CMDCOUNTER *cmd)
 {
     if (cmd->key().empty()) {
@@ -184,6 +190,12 @@ static lcb_STATUS counter_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_C
         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;
@@ -237,7 +249,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

@@ -112,6 +112,12 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdexists_on_behalf_of(lcb_CMDEXISTS *cmd, const
     return cmd->on_behalf_of(std::string(data, data_len));
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdexists_on_behalf_of_extra_privilege(lcb_CMDEXISTS *cmd, const char *privilege,
+                                                                       size_t privilege_len)
+{
+    return cmd->on_behalf_of_add_extra_privilege(std::string(privilege, privilege_len));
+}
+
 static lcb_STATUS exists_validate(lcb_INSTANCE *instance, const lcb_CMDEXISTS *cmd)
 {
     if (cmd->key().empty()) {
@@ -139,6 +145,12 @@ static lcb_STATUS exists_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;
@@ -153,7 +165,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 +180,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

@@ -129,6 +129,12 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdget_on_behalf_of(lcb_CMDGET *cmd, const char
     return cmd->on_behalf_of(std::string(data, data_len));
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdget_on_behalf_of_extra_privilege(lcb_CMDGET *cmd, const char *privilege,
+                                                                    size_t privilege_len)
+{
+    return cmd->on_behalf_of_add_extra_privilege(std::string(privilege, privilege_len));
+}
+
 static lcb_STATUS get_validate(lcb_INSTANCE *instance, const lcb_CMDGET *cmd)
 {
     if (cmd->key().empty()) {
@@ -159,6 +165,12 @@ static lcb_STATUS get_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CMDGE
         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;
@@ -187,7 +199,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 +221,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/get_replica.cc

@@ -144,6 +144,12 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetreplica_on_behalf_of(lcb_CMDGETREPLICA *cm
     return cmd->on_behalf_of(std::string(data, data_len));
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetreplica_on_behalf_of_extra_privilege(lcb_CMDGETREPLICA *cmd,
+                                                                           const char *privilege, size_t privilege_len)
+{
+    return cmd->on_behalf_of_add_extra_privilege(std::string(privilege, privilege_len));
+}
+
 struct RGetCookie : mc_REQDATAEX {
     RGetCookie(void *cookie, lcb_INSTANCE *instance, get_replica_mode, int vb);
     void decref()
@@ -349,20 +355,26 @@ static lcb_STATUS get_replica_schedule(lcb_INSTANCE *instance, std::shared_ptr<l
         return LCB_ERR_NO_MATCHING_SERVER;
     }
 
-    /* Initialize the cookie */
-    auto *rck = new RGetCookie(cmd->cookie(), instance, cmd->mode(), vbid);
-    rck->start = cmd->start_time_or_default_in_nanoseconds(gethrtime());
-    rck->deadline =
-        rck->start + cmd->timeout_or_default_in_nanoseconds(LCB_US2NS(LCBT_SETTING(instance, operation_timeout)));
-
     std::vector<std::uint8_t> framing_extras;
     if (cmd->want_impersonation()) {
         lcb_STATUS err = lcb::flexible_framing_extras::encode_impersonate_user(cmd->impostor(), framing_extras);
         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;
+            }
+        }
     }
 
+    /* Initialize the cookie */
+    auto *rck = new RGetCookie(cmd->cookie(), instance, cmd->mode(), vbid);
+    rck->start = cmd->start_time_or_default_in_nanoseconds(gethrtime());
+    rck->deadline =
+        rck->start + cmd->timeout_or_default_in_nanoseconds(LCB_US2NS(LCBT_SETTING(instance, operation_timeout)));
+
     /* Initialize the packet */
     req.request.magic = framing_extras.empty() ? PROTOCOL_BINARY_REQ : PROTOCOL_BINARY_AREQ;
     req.request.opcode = PROTOCOL_BINARY_CMD_GET_REPLICA;

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

@@ -117,6 +117,12 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdremove_on_behalf_of(lcb_CMDREMOVE *cmd, const
     return cmd->on_behalf_of(std::string(data, data_len));
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdremove_on_behalf_of_extra_privilege(lcb_CMDREMOVE *cmd, const char *privilege,
+                                                                       size_t privilege_len)
+{
+    return cmd->on_behalf_of_add_extra_privilege(std::string(privilege, privilege_len));
+}
+
 static lcb_STATUS remove_validate(lcb_INSTANCE *instance, const lcb_CMDREMOVE *cmd)
 {
     if (cmd->key().empty()) {
@@ -159,6 +165,12 @@ static lcb_STATUS remove_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;
@@ -188,7 +200,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

@@ -234,6 +234,12 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_on_behalf_of(lcb_CMDSTORE *cmd, const c
     return cmd->on_behalf_of(std::string(data, data_len));
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_on_behalf_of_extra_privilege(lcb_CMDSTORE *cmd, const char *privilege,
+                                                                      size_t privilege_len)
+{
+    return cmd->on_behalf_of_add_extra_privilege(std::string(privilege, privilege_len));
+}
+
 struct DurStoreCtx : mc_REQDATAEX {
     lcb_INSTANCE *instance;
     lcb_U16 persist_to;
@@ -400,6 +406,12 @@ static lcb_STATUS store_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CMD
         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;
+            }
+        }
     }
     auto ffextlen = static_cast<std::uint8_t>(framing_extras.size());
     hdr.request.magic = (ffextlen == 0) ? PROTOCOL_BINARY_REQ : PROTOCOL_BINARY_AREQ;
@@ -485,7 +497,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

@@ -409,6 +409,12 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_on_behalf_of(lcb_CMDSUBDOC *cmd, const
     return cmd->on_behalf_of(std::string(data, data_len));
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_on_behalf_of_extra_privilege(lcb_CMDSUBDOC *cmd, const char *privilege,
+                                                                       size_t privilege_len)
+{
+    return cmd->on_behalf_of_add_extra_privilege(std::string(privilege, privilege_len));
+}
+
 namespace SubdocCmdTraits
 {
 enum Options {
@@ -798,6 +804,12 @@ static lcb_STATUS subdoc_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
         if (rc != LCB_SUCCESS) {
             return rc;
         }
+        for (const auto &privilege : cmd->extra_privileges()) {
+            rc = lcb::flexible_framing_extras::encode_impersonate_users_extra_privilege(privilege, framing_extras);
+            if (rc != LCB_SUCCESS) {
+                return rc;
+            }
+        }
     }
     hdr.request.magic = framing_extras.empty() ? PROTOCOL_BINARY_REQ : PROTOCOL_BINARY_AREQ;
     auto ffextlen = static_cast<std::uint8_t>(framing_extras.size());
@@ -853,8 +865,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

@@ -117,6 +117,12 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdtouch_on_behalf_of(lcb_CMDTOUCH *cmd, const c
     return cmd->on_behalf_of(std::string(data, data_len));
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdtouch_on_behalf_of_extra_privilege(lcb_CMDTOUCH *cmd, const char *privilege,
+                                                                      size_t privilege_len)
+{
+    return cmd->on_behalf_of_add_extra_privilege(std::string(privilege, privilege_len));
+}
+
 static lcb_STATUS touch_validate(lcb_INSTANCE *instance, const lcb_CMDTOUCH *cmd)
 {
     if (cmd->key().empty()) {
@@ -142,6 +148,12 @@ static lcb_STATUS touch_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CMD
         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;
@@ -158,7 +170,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 +186,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;