couchbase 3.2.0 → 3.2.4

package/deps/lcb/src/lcbio/connect.cc

@@ -65,7 +65,7 @@ struct Connstart : ConnectionRequest {
     void cancel() override;
     void C_connect();
 
-    enum State { CS_PENDING, CS_CANCELLED, CS_CONNECTED, CS_ERROR };
+    enum State { CS_PENDING, CS_CANCELLED, CS_CONNECTED, CS_ERROR, CS_ERROR_CANCELLED };
 
     void state_signal(State next_state, lcb_STATUS err);
     void notify_success();
@@ -145,6 +145,12 @@ void Connstart::handler()
             sock->refcount--; /* dereference because of unsuccessful attempt */
         }
         goto GT_DTOR;
+    } else if (state == CS_ERROR_CANCELLED) {
+        /* same as above, except the refcount has already been decremented */
+        if (sock != nullptr && sock->io->is_C() && sock->u.sd) {
+            sock->u.sd->lcbconn = nullptr;
+        }
+        goto GT_DTOR;
     }
 
     if (sock) {
@@ -225,7 +231,13 @@ void Connstart::cancel()
         /* already inside user-defined handler */
         return;
     }
-    state = CS_CANCELLED;
+
+    if (state == CS_ERROR) {
+        state = CS_ERROR_CANCELLED;
+    } else {
+        state = CS_CANCELLED;
+    }
+
     handler();
 }
 

package/deps/lcb/src/lcbio/connect.h

@@ -75,8 +75,8 @@ typedef struct {
     struct sockaddr_storage sa_remote;
     struct sockaddr_storage sa_local;
     lcb_host_t ep_remote;
-    lcb_host_t ep_local2;
-    char ep_local[NI_MAXHOST + NI_MAXSERV + 2];
+    lcb_host_t ep_local;
+    char ep_local_host_and_port[NI_MAXHOST + 1 + NI_MAXSERV + 1];
 } lcbio_CONNINFO;
 
 struct lcb_IOMETRICS_st;

package/deps/lcb/src/lcbio/ctx.cc

@@ -136,8 +136,10 @@ void lcbio_ctx_close_ex(lcbio_CTX *ctx, lcbio_CTXCLOSE_cb cb, void *arg, lcbio_C
     }
 
     oldrc = ctx->sock->refcount;
-    lcb_log(LOGARGS(ctx, DEBUG), CTX_LOGFMT "Destroying context. Pending Writes=%d, Entered=%s, Socket Refcount=%d",
-            CTX_LOGID(ctx), (int)ctx->npending, (int)ctx->entered ? "true" : "false", oldrc);
+
+    lcb_log(LOGARGS(ctx, DEBUG),
+            CTX_LOGFMT "Destroying context for SOCK=%016" PRIx64 ". Pending Writes=%d, Entered=%s, Socket Refcount=%d",
+            CTX_LOGID(ctx), ctx->sock->id, (int)ctx->npending, (int)ctx->entered ? "true" : "false", oldrc);
 
     if (cb) {
         int reusable = ctx->npending == 0 &&      /* no pending events */

package/deps/lcb/src/lcbio/ioutils.cc

@@ -169,25 +169,24 @@ static int saddr_to_string(struct sockaddr *saddr, int len, char *buf, lcb_size_
 
 static void lcbio_cache_local_name(lcbio_CONNINFO *sock)
 {
+    char addr_str[NI_MAXHOST + 1];
     switch (sock->sa_local.ss_family) {
         case AF_INET: {
             auto *addr = (struct sockaddr_in *)&sock->sa_local;
-            inet_ntop(AF_INET, &(addr->sin_addr), sock->ep_local, sizeof(sock->ep_local));
-            strncpy(sock->ep_local2.host, sock->ep_local, sizeof(sock->ep_local2.host));
-            snprintf(sock->ep_local2.port, sizeof(sock->ep_local2.port), "%d", (int)ntohs(addr->sin_port));
-            size_t len = strlen(sock->ep_local);
-            snprintf(sock->ep_local + len, sizeof(sock->ep_local) - len, ":%d", (int)ntohs(addr->sin_port));
+            inet_ntop(AF_INET, &(addr->sin_addr), addr_str, sizeof(addr_str));
+            strncpy(sock->ep_local.host, addr_str, sizeof(sock->ep_local.host));
+            snprintf(sock->ep_local.port, sizeof(sock->ep_local.port), "%d", (int)ntohs(addr->sin_port));
         } break;
 
         case AF_INET6: {
             auto *addr = (struct sockaddr_in6 *)&sock->sa_local;
-            inet_ntop(AF_INET6, &(addr->sin6_addr), sock->ep_local, sizeof(sock->ep_local));
-            strncpy(sock->ep_local2.host, sock->ep_local, sizeof(sock->ep_local2.host));
-            snprintf(sock->ep_local2.port, sizeof(sock->ep_local2.port), "%d", (int)ntohs(addr->sin6_port));
-            size_t len = strlen(sock->ep_local);
-            snprintf(sock->ep_local + len, sizeof(sock->ep_local) - len, ":%d", (int)ntohs(addr->sin6_port));
+            inet_ntop(AF_INET6, &(addr->sin6_addr), addr_str, sizeof(addr_str));
+            strncpy(sock->ep_local.host, addr_str, sizeof(sock->ep_local.host));
+            snprintf(sock->ep_local.port, sizeof(sock->ep_local.port), "%d", (int)ntohs(addr->sin6_port));
         } break;
     }
+    snprintf(sock->ep_local_host_and_port, sizeof(sock->ep_local_host_and_port), "%s:%s", sock->ep_local.host,
+             sock->ep_local.port);
 }
 
 void lcbio__load_socknames(lcbio_SOCKET *sock)

package/deps/lcb/src/lcbio/manager.cc

@@ -282,7 +282,7 @@ static void endpointToJSON(hrtime_t now, Json::Value &node, const PoolHost *host
     endpoint["id"] = id;
     endpoint["remote"] = get_hehost(host);
     if (info->sock->info) {
-        endpoint["local"] = info->sock->info->ep_local;
+        endpoint["local"] = info->sock->info->ep_local_host_and_port;
         endpoint["last_activity_us"] = (Json::Value::UInt64)(now - info->sock->atime);
     }
     auto *session = lcb::SessionInfo::get(info->sock);

package/deps/lcb/src/mcserver/mcserver.cc

@@ -341,6 +341,11 @@ static bool is_fastpath_error(uint16_t rc)
         case PROTOCOL_BINARY_RESPONSE_SYNC_WRITE_IN_PROGRESS:
         case PROTOCOL_BINARY_RESPONSE_SYNC_WRITE_AMBIGUOUS:
         case PROTOCOL_BINARY_RESPONSE_LOCKED:
+        case PROTOCOL_BINARY_RATE_LIMITED_NETWORK_INGRESS:
+        case PROTOCOL_BINARY_RATE_LIMITED_NETWORK_EGRESS:
+        case PROTOCOL_BINARY_RATE_LIMITED_MAX_CONNECTIONS:
+        case PROTOCOL_BINARY_RATE_LIMITED_MAX_COMMANDS:
+        case PROTOCOL_BINARY_SCOPE_SIZE_LIMIT_EXCEEDED:
             return true;
         default:
             if (rc >= 0xc0 && rc <= 0xcc) {
@@ -395,10 +400,6 @@ int Server::handle_unknown_error(const mc_PACKET *request, const MemcachedRespon
         newerr = LCB_ERR_TEMPORARY_FAILURE;
     }
 
-    if (err.hasAttribute(errmap::CONSTRAINT_FAILURE)) {
-        newerr = LCB_ERR_CAS_MISMATCH;
-    }
-
     if (err.hasAttribute(errmap::AUTH)) {
         newerr = LCB_ERR_AUTHENTICATION_FAILURE;
     }
@@ -754,6 +755,8 @@ static const char *opcode_name(uint8_t code)
             return "subdoc_get_count";
         case PROTOCOL_BINARY_CMD_GET_ERROR_MAP:
             return "get_error_map";
+        case PROTOCOL_BINARY_CMD_GET_META:
+            return "exists";
         default:
             return "unknown";
     }
@@ -811,12 +814,12 @@ void Server::purge_single(mc_PACKET *pkt, lcb_STATUS err)
             snprintf(local_id, sizeof(local_id), "%016" PRIx64 "/%016" PRIx64 "/%x", settings->iid, connctx->sock->id,
                      (int)pkt->opaque);
             info["i"] = local_id;
-            info["l"] = connctx->sock->info->ep_local;
+            info["l"] = connctx->sock->info->ep_local_host_and_port;
         }
         std::string msg(Json::FastWriter().write(info));
         if (msg.size() > 1) {
             lcb_log(LOGARGS(instance, WARN), "Failing command with error %s: %.*s", lcb_strerror_short(err),
-                    (int)(msg.size() - 1), msg.c_str());
+                    (int)msg.size(), msg.c_str());
         }
     } else {
         lcb_log(LOGARGS_T(WARN), LOGFMT "Failing command (pkt=%p, opaque=%lu, opcode=0x%x) with error %s", LOGID_T(),

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;
         }
@@ -372,6 +384,10 @@ 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);
 }
 
@@ -390,9 +406,12 @@ lcb_STATUS lcb_QUERY_HANDLE_::issue_htreq(const std::string &body)
     lcb_cmdhttp_content_type(htcmd, content_type.c_str(), content_type.size());
     lcb_cmdhttp_method(htcmd, LCB_HTTP_METHOD_POST);
     lcb_cmdhttp_streaming(htcmd, true);
-    lcb_cmdhttp_timeout(htcmd, timeout);
+    lcb_cmdhttp_timeout(htcmd, timeout + LCBT_SETTING(instance_, n1ql_grace_period));
     lcb_cmdhttp_handle(htcmd, &http_request_);
     lcb_cmdhttp_host(htcmd, endpoint.data(), endpoint.size());
+    if (!impostor_.empty()) {
+        htcmd->set_header("cb-on-behalf-of", impostor_);
+    }
     if (use_multi_bucket_authentication_) {
         lcb_cmdhttp_skip_auth_header(htcmd, true);
     } else {
@@ -416,6 +435,10 @@ lcb_STATUS lcb_QUERY_HANDLE_::issue_htreq(const std::string &body)
     if (rc == LCB_SUCCESS) {
         http_request_->set_callback(reinterpret_cast<lcb_RESPCALLBACK>(chunk_callback));
     }
+    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());
     return rc;
 }
 
@@ -506,17 +529,14 @@ 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;
     }
-    lcb_log(LOGARGS(this, TRACE), LOGFMT "%.*s, idempotent=%s, timeout=%uus, grace_period=%uus", LOGID(this),
-            (int)statement_.size(), statement_.c_str(), idempotent_ ? "true" : "false", timeout,
-            LCBT_SETTING(obj, n1ql_grace_period));
     timeout_timer_.rearm(timeout + LCBT_SETTING(obj, n1ql_grace_period));
 
     // Determine if we need to add more credentials.
@@ -541,10 +561,12 @@ lcb_QUERY_HANDLE_::lcb_QUERY_HANDLE_(lcb_INSTANCE *obj, void *user_cookie, const
             curCreds["pass"] = ii->second;
         }
     }
+    if (cmd->want_impersonation()) {
+        impostor_ = cmd->impostor();
+    }
     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{};
 
@@ -290,6 +316,7 @@ struct lcb_QUERY_HANDLE_ : lcb::jsparse::Parser::Actions {
 
     lcb::io::Timer<lcb_QUERY_HANDLE_, &lcb_QUERY_HANDLE_::on_timeout> timeout_timer_;
     lcb::io::Timer<lcb_QUERY_HANDLE_, &lcb_QUERY_HANDLE_::on_backoff> backoff_timer_;
+    std::string impostor_{};
 };
 
 #endif // LIBCOUCHBASE_N1QL_QUERY_HANDLE_HH

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

@@ -136,6 +136,11 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdcounter_durability(lcb_CMDCOUNTER *cmd, lcb_D
     return cmd->durability_level(level);
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdcounter_on_behalf_of(lcb_CMDCOUNTER *cmd, const char *data, size_t data_len)
+{
+    return cmd->on_behalf_of(std::string(data, data_len));
+}
+
 static lcb_STATUS counter_validate(lcb_INSTANCE *instance, const lcb_CMDCOUNTER *cmd)
 {
     if (cmd->key().empty()) {
@@ -164,13 +169,21 @@ static lcb_STATUS counter_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_C
 
     std::vector<std::uint8_t> framing_extras;
     if (new_durability_supported && cmd->has_durability_requirements()) {
+        auto durability_timeout = htons(lcb_durability_timeout(instance, cmd->timeout_in_microseconds()));
         std::uint8_t frame_id = 0x01;
-        std::uint8_t frame_size = 0x04;
+        std::uint8_t frame_size = durability_timeout > 0 ? 3 : 1;
         framing_extras.emplace_back(frame_id << 4U | frame_size);
         framing_extras.emplace_back(cmd->durability_level());
-        auto durability_timeout = htons(lcb_durability_timeout(instance, cmd->timeout_in_microseconds()));
-        framing_extras.emplace_back(durability_timeout >> 8U);
-        framing_extras.emplace_back(durability_timeout & 0xff);
+        if (durability_timeout > 0) {
+            framing_extras.emplace_back(durability_timeout >> 8U);
+            framing_extras.emplace_back(durability_timeout & 0xff);
+        }
+    }
+    if (cmd->want_impersonation()) {
+        err = lcb::flexible_framing_extras::encode_impersonate_user(cmd->impostor(), framing_extras);
+        if (err != LCB_SUCCESS) {
+            return err;
+        }
     }
 
     hdr.request.magic = framing_extras.empty() ? PROTOCOL_BINARY_REQ : PROTOCOL_BINARY_AREQ;
@@ -224,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

@@ -107,6 +107,11 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdexists_key(lcb_CMDEXISTS *cmd, const char *ke
     return cmd->key(std::string(key, key_len));
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdexists_on_behalf_of(lcb_CMDEXISTS *cmd, const char *data, size_t data_len)
+{
+    return cmd->on_behalf_of(std::string(data, data_len));
+}
+
 static lcb_STATUS exists_validate(lcb_INSTANCE *instance, const lcb_CMDEXISTS *cmd)
 {
     if (cmd->key().empty()) {
@@ -123,12 +128,24 @@ static lcb_STATUS exists_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
 {
     mc_CMDQUEUE *cq = &instance->cmdq;
 
-    protocol_binary_request_header hdr;
+    protocol_binary_request_header hdr{};
     mc_PIPELINE *pipeline;
     mc_PACKET *pkt;
     lcb_STATUS err;
+
+    std::vector<std::uint8_t> framing_extras;
+    if (cmd->want_impersonation()) {
+        err = lcb::flexible_framing_extras::encode_impersonate_user(cmd->impostor(), framing_extras);
+        if (err != LCB_SUCCESS) {
+            return err;
+        }
+    }
+
+    hdr.request.magic = framing_extras.empty() ? PROTOCOL_BINARY_REQ : PROTOCOL_BINARY_AREQ;
+    auto ffextlen = static_cast<std::uint8_t>(framing_extras.size());
+
     lcb_KEYBUF keybuf{LCB_KV_COPY, {cmd->key().c_str(), cmd->key().size()}};
-    err = mcreq_basic_packet(cq, &keybuf, cmd->collection().collection_id(), &hdr, 0, 0, &pkt, &pipeline,
+    err = mcreq_basic_packet(cq, &keybuf, cmd->collection().collection_id(), &hdr, 0, ffextlen, &pkt, &pipeline,
                              MCREQ_BASICPACKET_F_FALLBACKOK);
     if (err != LCB_SUCCESS) {
         return err;
@@ -136,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;
 
@@ -146,8 +163,12 @@ static lcb_STATUS exists_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
         pkt->u_rdata.reqdata.start +
         cmd->timeout_or_default_in_nanoseconds(LCB_US2NS(LCBT_SETTING(instance, operation_timeout)));
     memcpy(SPAN_BUFFER(&pkt->kh_span), hdr.bytes, MCREQ_PKT_BASESIZE);
+    std::size_t offset = sizeof(hdr);
+    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_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

@@ -124,6 +124,11 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdget_locktime(lcb_CMDGET *cmd, uint32_t durati
     return cmd->with_lock(duration);
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdget_on_behalf_of(lcb_CMDGET *cmd, const char *data, size_t data_len)
+{
+    return cmd->on_behalf_of(std::string(data, data_len));
+}
+
 static lcb_STATUS get_validate(lcb_INSTANCE *instance, const lcb_CMDGET *cmd)
 {
     if (cmd->key().empty()) {
@@ -145,11 +150,20 @@ static lcb_STATUS get_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CMDGE
     mc_CMDQUEUE *q = &instance->cmdq;
     lcb_uint8_t extlen = 0;
     lcb_uint8_t opcode = PROTOCOL_BINARY_CMD_GET;
-    protocol_binary_request_gat gcmd;
-    protocol_binary_request_header *hdr = &gcmd.message.header;
+    protocol_binary_request_header hdr{};
     lcb_STATUS err;
 
-    hdr->request.magic = PROTOCOL_BINARY_REQ;
+    std::vector<std::uint8_t> framing_extras;
+    if (cmd->want_impersonation()) {
+        err = lcb::flexible_framing_extras::encode_impersonate_user(cmd->impostor(), framing_extras);
+        if (err != LCB_SUCCESS) {
+            return err;
+        }
+    }
+
+    hdr.request.magic = framing_extras.empty() ? PROTOCOL_BINARY_REQ : PROTOCOL_BINARY_AREQ;
+    auto ffextlen = static_cast<std::uint8_t>(framing_extras.size());
+
     if (cmd->with_lock()) {
         extlen = 4;
         opcode = PROTOCOL_BINARY_CMD_GET_LOCKED;
@@ -159,7 +173,7 @@ static lcb_STATUS get_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CMDGE
     }
 
     lcb_KEYBUF keybuf{LCB_KV_COPY, {cmd->key().c_str(), cmd->key().size()}};
-    err = mcreq_basic_packet(q, &keybuf, cmd->collection().collection_id(), hdr, extlen, 0, &pkt, &pl,
+    err = mcreq_basic_packet(q, &keybuf, cmd->collection().collection_id(), &hdr, extlen, ffextlen, &pkt, &pl,
                              MCREQ_BASICPACKET_F_FALLBACKOK);
     if (err != LCB_SUCCESS) {
         return err;
@@ -171,27 +185,33 @@ static lcb_STATUS get_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CMDGE
     rdata->deadline =
         rdata->start + cmd->timeout_or_default_in_nanoseconds(LCB_US2NS(LCBT_SETTING(instance, operation_timeout)));
 
-    hdr->request.opcode = opcode;
-    hdr->request.datatype = PROTOCOL_BINARY_RAW_BYTES;
-    hdr->request.bodylen = htonl(extlen + ntohs(hdr->request.keylen));
-    hdr->request.opaque = pkt->opaque;
-    hdr->request.cas = 0;
-
-    if (cmd->with_lock()) {
-        gcmd.message.body.norm.expiration = htonl(cmd->lock_time());
-    }
-    if (extlen) {
-        gcmd.message.body.norm.expiration = htonl(cmd->expiry());
-    }
+    hdr.request.opcode = opcode;
+    hdr.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
+    hdr.request.bodylen = htonl(extlen + ffextlen + mcreq_get_key_size(&hdr));
+    hdr.request.opaque = pkt->opaque;
+    hdr.request.cas = 0;
 
     if (cmd->is_cookie_callback()) {
         pkt->flags |= MCREQ_F_PRIVCALLBACK;
     }
 
-    memcpy(SPAN_BUFFER(&pkt->kh_span), gcmd.bytes, MCREQ_PKT_BASESIZE + extlen);
-    LCBTRACE_KV_START(instance->settings, pkt->opaque, cmd, LCBTRACE_OP_GET, rdata->span);
+    memcpy(SPAN_BUFFER(&pkt->kh_span), &hdr, sizeof(hdr));
+    std::size_t offset = sizeof(hdr);
+    if (!framing_extras.empty()) {
+        memcpy(SPAN_BUFFER(&pkt->kh_span) + offset, framing_extras.data(), framing_extras.size());
+        offset += framing_extras.size();
+    }
+    if (cmd->with_lock()) {
+        std::uint32_t lock_expiry = htonl(cmd->lock_time());
+        memcpy(SPAN_BUFFER(&pkt->kh_span) + offset, &lock_expiry, sizeof(lock_expiry));
+    } else if (cmd->with_touch()) {
+        std::uint32_t expiry = htonl(cmd->expiry());
+        memcpy(SPAN_BUFFER(&pkt->kh_span) + offset, &expiry, sizeof(expiry));
+    }
+
+    rdata->span = lcb::trace::start_kv_span(instance->settings, pkt, cmd);
     LCB_SCHED_ADD(instance, pl, pkt)
-    TRACE_GET_BEGIN(instance, hdr, cmd);
+    TRACE_GET_BEGIN(instance, &hdr, cmd);
     return LCB_SUCCESS;
 }