couchbase 3.2.0 → 3.2.4

package/deps/lcb/src/utilities.h

@@ -0,0 +1,53 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2018-2020 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#ifndef LIBCOUCHBASE_UTILITIES_H
+#define LIBCOUCHBASE_UTILITIES_H 1
+
+#include "config.h"
+
+#ifdef __cplusplus
+#include <string>
+#include <vector>
+
+namespace lcb
+{
+namespace flexible_framing_extras
+{
+lcb_STATUS encode_impersonate_user(const std::string &username, std::vector<std::uint8_t> &flexible_framing_extras);
+} // namespace flexible_framing_extras
+} // namespace lcb
+
+extern "C" {
+#endif
+
+/**
+ * Added to avoid triggering unexpected behaviour of strdup from stdlib.
+ * See https://stackoverflow.com/questions/8359966/strdup-returning-address-out-of-bounds
+ *
+ * All usages have to be replaced with std::string eventually.
+ *
+ * @private
+ */
+LCB_INTERNAL_API
+char *lcb_strdup(const char *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/deps/lcb/src/vbucket/vbucket.c

@@ -25,6 +25,7 @@
 #include "json-inl.h"
 #include "hash.h"
 #include "crc32.h"
+#include "utilities.h"
 
 #define STRINGIFY_(X) #X
 #define STRINGIFY(X) STRINGIFY_(X)
@@ -118,7 +119,7 @@ static int assign_dumy_server(lcbvb_CONFIG *cfg, lcbvb_SERVER *dst, const char *
 {
     int itmp;
     char *colon;
-    if (!(dst->authority = strdup(s))) {
+    if (!(dst->authority = lcb_strdup(s))) {
         SET_ERRSTR(cfg, "Couldn't allocate authority string");
         goto GT_ERR;
     }
@@ -354,28 +355,28 @@ static int build_server_strings(lcbvb_CONFIG *cfg, lcbvb_SERVER *server)
     char tmpbuf[4096];
 
     copy_address(tmpbuf, sizeof(tmpbuf), server->hostname, server->svc.data);
-    server->authority = strdup(tmpbuf);
+    server->authority = lcb_strdup(tmpbuf);
     if (!server->authority) {
         SET_ERRSTR(cfg, "Couldn't allocate authority");
         return 0;
     }
 
-    server->svc.hoststrs[LCBVB_SVCTYPE_DATA] = strdup(server->authority);
+    server->svc.hoststrs[LCBVB_SVCTYPE_DATA] = lcb_strdup(server->authority);
     if (server->viewpath == NULL && server->svc.views && cfg->bname) {
         server->viewpath = malloc(strlen(cfg->bname) + 2);
         sprintf(server->viewpath, "/%s", cfg->bname);
     }
     if (server->querypath == NULL && server->svc.n1ql) {
-        server->querypath = strdup("/query/service");
+        server->querypath = lcb_strdup("/query/service");
     }
     if (server->ftspath == NULL && server->svc.fts) {
-        server->ftspath = strdup("/");
+        server->ftspath = lcb_strdup("/");
     }
     if (server->cbaspath == NULL && server->svc.cbas) {
-        server->cbaspath = strdup("");
+        server->cbaspath = lcb_strdup("");
     }
     if (server->eventingpath == NULL && server->svc.eventing) {
-        server->eventingpath = strdup("");
+        server->eventingpath = lcb_strdup("");
     }
     return 1;
 }
@@ -395,7 +396,7 @@ static int build_server_3x(lcbvb_CONFIG *cfg, lcbvb_SERVER *server, cJSON *js, c
     if (!get_jstr(js, "hostname", &htmp)) {
         htmp = "$HOST";
     }
-    if (!(server->hostname = strdup(htmp))) {
+    if (!(server->hostname = lcb_strdup(htmp))) {
         SET_ERRSTR(cfg, "Couldn't allocate memory");
         goto GT_ERR;
     }
@@ -422,7 +423,7 @@ static int build_server_3x(lcbvb_CONFIG *cfg, lcbvb_SERVER *server, cJSON *js, c
             cJSON *jnetwork = cJSON_GetObjectItem(jaltaddr, *network);
             if (jnetwork && get_jstr(jnetwork, "hostname", &htmp)) {
                 cJSON *jports;
-                server->alt_hostname = strdup(htmp);
+                server->alt_hostname = lcb_strdup(htmp);
                 jports = cJSON_GetObjectItem(jnetwork, "ports");
                 if (jports && jports->type == cJSON_Object) {
                     extract_services(cfg, jports, &server->alt_svc, 0);
@@ -481,7 +482,7 @@ static int build_server_2x(lcbvb_CONFIG *cfg, lcbvb_SERVER *server, cJSON *js)
     }
 
     /** Hostname is the _rest_ API host, e.g. '8091' */
-    if ((server->hostname = strdup(tmp)) == NULL) {
+    if ((server->hostname = lcb_strdup(tmp)) == NULL) {
         SET_ERRSTR(cfg, "Couldn't allocate hostname");
         goto GT_ERR;
     }
@@ -521,7 +522,7 @@ static int build_server_2x(lcbvb_CONFIG *cfg, lcbvb_SERVER *server, cJSON *js)
             SET_ERRSTR(cfg, "Expected path in couchApiBase");
             goto GT_ERR;
         }
-        server->viewpath = strdup(path_begin);
+        server->viewpath = lcb_strdup(path_begin);
     } else {
         server->svc.views = 0;
     }
@@ -559,7 +560,7 @@ static void guess_network(cJSON *jnodes, int nsrv, const char *source, char **ne
             cJSON *jhostname = cJSON_GetObjectItem(jsrv, "hostname");
             if (jhostname && jhostname->type == cJSON_String) {
                 if (strcmp(jhostname->valuestring, source) == 0) {
-                    *network = strdup("default");
+                    *network = lcb_strdup("default");
                     return;
                 }
             }
@@ -573,7 +574,7 @@ static void guess_network(cJSON *jnodes, int nsrv, const char *source, char **ne
                         cJSON *jhostname = cJSON_GetObjectItem(cur, "hostname");
                         if (jhostname && jhostname->type == cJSON_String) {
                             if (strcmp(jhostname->valuestring, source) == 0) {
-                                *network = strdup(cur->string);
+                                *network = lcb_strdup(cur->string);
                                 return;
                             }
                         }
@@ -582,7 +583,7 @@ static void guess_network(cJSON *jnodes, int nsrv, const char *source, char **ne
             }
         }
     }
-    *network = strdup("default");
+    *network = lcb_strdup("default");
 }
 
 int lcbvb_load_json_ex(lcbvb_CONFIG *cfg, const char *data, const char *source, char **network)
@@ -604,7 +605,7 @@ int lcbvb_load_json_ex(lcbvb_CONFIG *cfg, const char *data, const char *source,
     }
 
     if (!is_cluster_cfg && get_jstr(cj, "name", &tmp)) {
-        cfg->bname = strdup(tmp);
+        cfg->bname = lcb_strdup(tmp);
         cfg->bname_len = strlen(cfg->bname);
     }
 
@@ -618,7 +619,7 @@ int lcbvb_load_json_ex(lcbvb_CONFIG *cfg, const char *data, const char *source,
     }
 
     if (get_jstr(cj, "uuid", &tmp)) {
-        cfg->buuid = strdup(tmp);
+        cfg->buuid = lcb_strdup(tmp);
     }
 
     if (!get_jint64(cj, "revEpoch", &cfg->revepoch)) {
@@ -824,7 +825,7 @@ void lcbvb_replace_host(lcbvb_CONFIG *cfg, const char *hoststr)
         }
         /* reassign authority */
         free(srv->authority);
-        srv->authority = strdup(srv->svc.hoststrs[LCBVB_SVCTYPE_DATA]);
+        srv->authority = lcb_strdup(srv->svc.hoststrs[LCBVB_SVCTYPE_DATA]);
     }
     if (copy) {
         free(replacement);
@@ -1570,7 +1571,7 @@ const char *lcbvb_get_resturl(lcbvb_CONFIG *cfg, unsigned ix, lcbvb_SVCTYPE svc,
         } else {
             snprintf(buf, sizeof(buf), "%s://%s:%d%s", prefix, hostname, port, path);
         }
-        *strp = strdup(buf);
+        *strp = lcb_strdup(buf);
     }
 
     return *strp;
@@ -1617,24 +1618,24 @@ static void copy_service(const char *hostname, const lcbvb_SERVICES *src, lcbvb_
     *dst = *src;
     memset(&dst->hoststrs, 0, sizeof dst->hoststrs);
     if (src->views_base_) {
-        dst->views_base_ = strdup(src->views_base_);
+        dst->views_base_ = lcb_strdup(src->views_base_);
     }
     if (src->query_base_) {
-        dst->query_base_ = strdup(src->query_base_);
+        dst->query_base_ = lcb_strdup(src->query_base_);
     }
     if (src->fts_base_) {
-        dst->fts_base_ = strdup(src->fts_base_);
+        dst->fts_base_ = lcb_strdup(src->fts_base_);
     }
     if (src->cbas_base_) {
-        dst->cbas_base_ = strdup(src->cbas_base_);
+        dst->cbas_base_ = lcb_strdup(src->cbas_base_);
     }
     if (src->eventing_base_) {
-        dst->eventing_base_ = strdup(src->eventing_base_);
+        dst->eventing_base_ = lcb_strdup(src->eventing_base_);
     }
     if (dst->data) {
         char buf[4096];
         copy_address(buf, sizeof(buf), hostname, dst->data);
-        dst->hoststrs[LCBVB_SVCTYPE_DATA] = strdup(buf);
+        dst->hoststrs[LCBVB_SVCTYPE_DATA] = lcb_strdup(buf);
     }
 }
 
@@ -1656,12 +1657,12 @@ int lcbvb_genconfig_ex(lcbvb_CONFIG *vb, const char *name, const char *uuid, con
     vb->nvb = nvbuckets;
     vb->nrepl = nreplica;
     vb->nsrv = nservers;
-    vb->bname = strdup(name);
+    vb->bname = lcb_strdup(name);
     if (vb->bname) {
         vb->bname_len = strlen(vb->bname);
     }
     if (uuid) {
-        vb->buuid = strdup(uuid);
+        vb->buuid = lcb_strdup(uuid);
     }
 
     if (nreplica >= nservers) {
@@ -1713,21 +1714,21 @@ int lcbvb_genconfig_ex(lcbvb_CONFIG *vb, const char *name, const char *uuid, con
         const lcbvb_SERVER *src = servers + ii;
 
         *dst = *src;
-        dst->hostname = strdup(src->hostname);
+        dst->hostname = lcb_strdup(src->hostname);
         if (src->viewpath) {
-            dst->viewpath = strdup(src->viewpath);
+            dst->viewpath = lcb_strdup(src->viewpath);
         }
         if (src->querypath) {
-            dst->querypath = strdup(src->querypath);
+            dst->querypath = lcb_strdup(src->querypath);
         }
         if (src->ftspath) {
-            dst->ftspath = strdup(src->ftspath);
+            dst->ftspath = lcb_strdup(src->ftspath);
         }
         if (src->cbaspath) {
-            dst->cbaspath = strdup(src->cbaspath);
+            dst->cbaspath = lcb_strdup(src->cbaspath);
         }
         if (src->eventingpath) {
-            dst->eventingpath = strdup(src->eventingpath);
+            dst->eventingpath = lcb_strdup(src->eventingpath);
         }
 
         copy_service(src->hostname, &src->svc, &dst->svc);
@@ -1735,7 +1736,7 @@ int lcbvb_genconfig_ex(lcbvb_CONFIG *vb, const char *name, const char *uuid, con
         {
             char tmpbuf[MAX_AUTHORITY_SIZE] = {0};
             copy_address(tmpbuf, sizeof(tmpbuf), dst->hostname, dst->svc.data);
-            dst->authority = strdup(tmpbuf);
+            dst->authority = lcb_strdup(tmpbuf);
         }
     }
 

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);
 }

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

@@ -118,6 +118,32 @@ struct lcb_VIEW_HANDLE_ : lcb::jsparse::Parser::Actions {
         return http_request_;
     }
 
+    static lcbtrace_THRESHOLDOPTS service()
+    {
+        return LCBTRACE_THRESHOLD_VIEW;
+    }
+
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_VIEW;
+        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:
     /** Current HTTP response to provide in callbacks */
     const lcb_RESPHTTP *http_response_{nullptr};
@@ -134,12 +160,15 @@ struct lcb_VIEW_HANDLE_ : lcb::jsparse::Parser::Actions {
     std::string query_params_{};
     std::string first_error_code_{};
     std::string first_error_message_{};
+    std::string client_context_id_{};
 
     unsigned refcount_{1};
     bool include_docs_{false};
     bool do_not_parse_rows_{false};
     bool spatial_{false};
+    int retries_{0};
 
     lcb_STATUS last_error_{LCB_SUCCESS};
+    lcbtrace_SPAN *parent_span_{nullptr};
     lcbtrace_SPAN *span_{nullptr};
 };

package/deps/lcb/tests/CMakeLists.txt

@@ -152,8 +152,29 @@ MACRO(DEFINE_MOCKTEST plugin test)
             --tests ${test}
             --verbose
             --
+            --gtest_filter="-ContaminatingUnitTest.*"
+            --gtest_throw_on_failure=1
             --gtest_print_time=1
             --gtest_output=xml:"${PROJECT_BINARY_DIR}/REPORT_${plugin}_${test}.xml")
+    SET_TESTS_PROPERTIES(check-${plugin}-${test} PROPERTIES LABELS "normal" )
+
+    ADD_TEST(
+            NAME
+            check-contaminating-${plugin}-${test}
+            COMMAND
+            $<TARGET_FILE:check-all>
+            --srcdir "${PROJECT_SOURCE_DIR}"
+            --testdir "$<TARGET_FILE_DIR:check-all>"
+            --libdir "$<TARGET_FILE_DIR:couchbase>"
+            --plugins ${plugin}
+            --tests ${test}
+            --verbose
+            --
+            --gtest_filter="ContaminatingUnitTest.*"
+            --gtest_throw_on_failure=1
+            --gtest_print_time=1
+            --gtest_output=xml:"${PROJECT_BINARY_DIR}/REPORT_${plugin}_${test}.xml")
+    SET_TESTS_PROPERTIES(check-contaminating-${plugin}-${test} PROPERTIES LABELS "contaminating" )
 ENDMACRO()
 
 # Since we need a plugin name, we'll use 'select'. However none of these

package/deps/lcb/tests/basic/t_ctlcodes.cc

@@ -18,6 +18,9 @@
 #include "config.h"
 #include <gtest/gtest.h>
 #include <libcouchbase/couchbase.h>
+#include <iotests/testutil.h>
+
+#include "internal.h"
 
 class CtlTest : public ::testing::Test
 {
@@ -61,9 +64,9 @@ TEST_F(CtlTest, testStringCtls)
 {
     lcb_INSTANCE *instance;
     lcb_STATUS err;
-    err = lcb_create(&instance, NULL);
+    err = lcb_create(&instance, nullptr);
     ASSERT_EQ(LCB_SUCCESS, err);
-    ASSERT_FALSE(instance == NULL);
+    ASSERT_FALSE(instance == nullptr);
 
     // These are all U32
     PairMap ctlMap[] = {{"operation_timeout", LCB_CNTL_OP_TIMEOUT},
@@ -74,7 +77,7 @@ TEST_F(CtlTest, testStringCtls)
                         {"error_thresh_delay", LCB_CNTL_CONFDELAY_THRESH},
                         {"config_total_timeout", LCB_CNTL_CONFIGURATION_TIMEOUT},
                         {"config_node_timeout", LCB_CNTL_CONFIG_NODE_TIMEOUT},
-                        {NULL, 0}};
+                        {nullptr, 0}};
 
     for (PairMap *cur = ctlMap; cur->key; cur++) {
         err = lcb_cntl_string(instance, cur->key, "50");
@@ -111,3 +114,21 @@ TEST_F(CtlTest, testStringCtls)
 
     lcb_destroy(instance);
 }
+
+TEST_F(CtlTest, testTimeDurationParsing)
+{
+    lcb_INSTANCE *instance;
+    ASSERT_EQ(LCB_SUCCESS, lcb_create(&instance, nullptr));
+    ASSERT_FALSE(instance == nullptr);
+
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cntl_string(instance, "analytics_timeout", "123.456"));
+    ASSERT_EQ(123456000, instance->settings->analytics_timeout);
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cntl_string(instance, "analytics_timeout", "42"));
+    ASSERT_EQ(42000000, instance->settings->analytics_timeout);
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cntl_string(instance, "analytics_timeout", "42us"));
+    ASSERT_EQ(42, instance->settings->analytics_timeout);
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cntl_string(instance, "analytics_timeout", "5s42us"));
+    ASSERT_EQ(5000042, instance->settings->analytics_timeout);
+
+    lcb_destroy(instance);
+}

package/deps/lcb/tests/basic/t_jsparse.cc

@@ -105,3 +105,11 @@ TEST_F(JsonParseTest, testN1QL)
     ASSERT_TRUE(validateJsonRows(JSON_n1ql_empty, sizeof(JSON_n1ql_empty), Parser::MODE_N1QL));
     ASSERT_TRUE(validateBadParse(JSON_n1ql_bad, sizeof(JSON_n1ql_bad), Parser::MODE_N1QL));
 }
+
+TEST_F(JsonParseTest, testInvalidJSON)
+{
+    std::string input = "503 Service Unavailable";
+    Json::Value meta;
+    ASSERT_TRUE(Json::Reader().parse(input.c_str(), input.c_str() + input.size(), meta));
+    ASSERT_FALSE(Json::Reader(Json::Features::strictMode()).parse(input.c_str(), input.c_str() + input.size(), meta));
+}

package/deps/lcb/tests/basic/t_n1qlstrings.cc

@@ -20,6 +20,7 @@
 #include <libcouchbase/couchbase.h>
 
 #include "n1ql/query_utils.hh"
+#include "../iotests/testutil.h"
 
 class N1qLStringTests : public ::testing::Test
 {
@@ -35,3 +36,75 @@ TEST_F(N1qLStringTests, testParseTimeout)
     ASSERT_THROW(lcb_parse_golang_duration("124"), lcb_duration_parse_error);
     ASSERT_THROW(lcb_parse_golang_duration("99z"), lcb_duration_parse_error);
 }
+
+TEST_F(N1qLStringTests, testQueryPositionalParams)
+{
+    lcb_CMDQUERY *cmd = nullptr;
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdquery_create(&cmd));
+
+    std::string statement = "SELECT 42 AS the_answer WHERE question IN (?, ?, ?) ";
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdquery_statement(cmd, statement.c_str(), statement.size()));
+
+    const char *payload = nullptr;
+    size_t payload_len = 0;
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdquery_encoded_payload(cmd, &payload, &payload_len));
+    ASSERT_TRUE(payload != nullptr && payload_len > 0);
+    ASSERT_EQ(R"({"statement":"SELECT 42 AS the_answer WHERE question IN (?, ?, ?) "})",
+              std::string(payload, payload_len));
+
+    std::vector<std::string> question{"\"life\"", "\"Universe\"", "\"Everything\""};
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdquery_positional_param(cmd, question[0].c_str(), question[0].size()));
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdquery_positional_param(cmd, question[1].c_str(), question[1].size()));
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdquery_positional_param(cmd, question[2].c_str(), question[2].size()));
+
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdquery_encoded_payload(cmd, &payload, &payload_len));
+    ASSERT_TRUE(payload != nullptr && payload_len > 0);
+    ASSERT_EQ(
+        R"({"args":["life","Universe","Everything"],"statement":"SELECT 42 AS the_answer WHERE question IN (?, ?, ?) "})",
+        std::string(payload, payload_len));
+
+    std::string questions{R"(["Universe", "life", "Everything"])"};
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdquery_positional_params(cmd, questions.c_str(), questions.size()));
+
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdquery_encoded_payload(cmd, &payload, &payload_len));
+    ASSERT_TRUE(payload != nullptr && payload_len > 0);
+    ASSERT_EQ(
+        R"({"args":["Universe","life","Everything"],"statement":"SELECT 42 AS the_answer WHERE question IN (?, ?, ?) "})",
+        std::string(payload, payload_len));
+}
+
+TEST_F(N1qLStringTests, testAnalyticsPositionalParams)
+{
+    lcb_CMDANALYTICS *cmd = nullptr;
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdanalytics_create(&cmd));
+
+    std::string statement = "SELECT 42 AS the_answer WHERE question IN (?, ?, ?) ";
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdanalytics_statement(cmd, statement.c_str(), statement.size()));
+
+    const char *payload = nullptr;
+    size_t payload_len = 0;
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdanalytics_encoded_payload(cmd, &payload, &payload_len));
+    ASSERT_TRUE(payload != nullptr && payload_len > 0);
+    ASSERT_EQ(R"({"statement":"SELECT 42 AS the_answer WHERE question IN (?, ?, ?) "})",
+              std::string(payload, payload_len));
+
+    std::vector<std::string> question{"\"life\"", "\"Universe\"", "\"Everything\""};
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdanalytics_positional_param(cmd, question[0].c_str(), question[0].size()));
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdanalytics_positional_param(cmd, question[1].c_str(), question[1].size()));
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdanalytics_positional_param(cmd, question[2].c_str(), question[2].size()));
+
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdanalytics_encoded_payload(cmd, &payload, &payload_len));
+    ASSERT_TRUE(payload != nullptr && payload_len > 0);
+    ASSERT_EQ(
+        R"({"args":["life","Universe","Everything"],"statement":"SELECT 42 AS the_answer WHERE question IN (?, ?, ?) "})",
+        std::string(payload, payload_len));
+
+    std::string questions{R"(["Universe", "life", "Everything"])"};
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdanalytics_positional_params(cmd, questions.c_str(), questions.size()));
+
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdanalytics_encoded_payload(cmd, &payload, &payload_len));
+    ASSERT_TRUE(payload != nullptr && payload_len > 0);
+    ASSERT_EQ(
+        R"({"args":["Universe","life","Everything"],"statement":"SELECT 42 AS the_answer WHERE question IN (?, ?, ?) "})",
+        std::string(payload, payload_len));
+}

package/deps/lcb/tests/iotests/mock-environment.cc

@@ -21,6 +21,7 @@
 #include "mock-environment.h"
 #include <sstream>
 #include "internal.h" /* settings from lcb_INSTANCE *for logging */
+#include "testutil.h"
 
 #define LOGARGS(instance, lvl) instance->settings, "tests-ENV", LCB_LOG_##lvl, __FILE__, __LINE__
 
@@ -288,6 +289,7 @@ void MockEnvironment::createConnection(HandleWrap &handle, lcb_INSTANCE **instan
     }
 
     lcb_createopts_io(&options, io);
+
     lcb_STATUS err = lcb_create(instance, &options);
     ASSERT_EQ(LCB_SUCCESS, err);
     postCreate(*instance);
@@ -302,6 +304,26 @@ void MockEnvironment::createConnection(HandleWrap &handle, lcb_INSTANCE **instan
 {
     lcb_CREATEOPTS *options = nullptr;
     makeConnectParams(options, nullptr);
+
+    if (test_tracer.enabled()) {
+        lcb_createopts_tracer(options, test_tracer.lcb_tracer());
+    }
+
+    if (test_meter.enabled()) {
+        lcb_createopts_meter(options, test_meter.lcb_meter());
+    }
+
+    createConnection(handle, instance, options);
+    lcb_createopts_destroy(options);
+}
+
+void MockEnvironment::createConnection(HandleWrap &handle, lcb_INSTANCE **instance, const std::string &username,
+                                       const std::string &password)
+{
+    lcb_CREATEOPTS *options = nullptr;
+    makeConnectParams(options, nullptr);
+
+    lcb_createopts_credentials(options, username.c_str(), username.size(), password.c_str(), password.size());
     createConnection(handle, instance, options);
     lcb_createopts_destroy(options);
 }
@@ -323,6 +345,10 @@ static void statsCallback(lcb_INSTANCE *instance, lcb_CALLBACK_TYPE, const lcb_R
 {
     MockEnvironment *me = nullptr;
     lcb_respstats_cookie(resp, (void **)&me);
+    if (me->getServerVersion() != MockEnvironment::VERSION_UNKNOWN) {
+        // ignore all subsequent responses
+        return;
+    }
     lcb_STATUS rc = lcb_respstats_status(resp);
     ASSERT_EQ(LCB_SUCCESS, rc) << lcb_strerror_short(rc);
 
@@ -542,6 +568,9 @@ void MockEnvironment::SetUp()
     featureRegistry.insert("replica_read");
     featureRegistry.insert("lock");
 
+    test_tracer = TestTracer();
+    test_meter = TestMeter();
+
     clearAndReset();
 }
 
@@ -591,7 +620,7 @@ MockCommand::MockCommand(Code code)
 std::string MockCommand::encode()
 {
     finalizePayload();
-    return Json::FastWriter().write(command);
+    return Json::FastWriter().write(command) + "\n";
 }
 
 void MockKeyCommand::finalizePayload()