couchbase 3.2.2 → 3.2.5

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/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,15 @@ 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);
 }
@@ -311,6 +322,7 @@ void MockEnvironment::createConnection(HandleWrap &handle, lcb_INSTANCE **instan
 {
     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);
@@ -411,7 +423,16 @@ static void statsCallback(lcb_INSTANCE *instance, lcb_CALLBACK_TYPE, const lcb_R
                 }
                 break;
             case 7:
-                version = MockEnvironment::VERSION_70;
+                switch (minor) {
+                    case 0:
+                        version = MockEnvironment::VERSION_70;
+                        break;
+                    case 1:
+                        version = MockEnvironment::VERSION_71;
+                        break;
+                    default:
+                        break;
+                }
                 break;
             default:
                 break;
@@ -556,6 +577,9 @@ void MockEnvironment::SetUp()
     featureRegistry.insert("replica_read");
     featureRegistry.insert("lock");
 
+    test_tracer = TestTracer();
+    test_meter = TestMeter();
+
     clearAndReset();
 }
 

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

@@ -20,6 +20,7 @@
 #include "config.h"
 #include <gtest/gtest.h>
 #include <libcouchbase/couchbase.h>
+#include "testutil.h"
 
 #include <utility>
 #include "serverparams.h"
@@ -245,7 +246,8 @@ class MockEnvironment : public ::testing::Environment
         VERSION_60 = 10,
         VERSION_65 = 11,
         VERSION_66 = 12,
-        VERSION_70 = 13
+        VERSION_70 = 13,
+        VERSION_71 = 14,
     };
 
     void SetUp() override;
@@ -451,6 +453,16 @@ class MockEnvironment : public ::testing::Environment
         std::cerr << std::endl;
     }
 
+    TestTracer &getTracer()
+    {
+        return test_tracer;
+    }
+
+    TestMeter &getMeter()
+    {
+        return test_meter;
+    }
+
     explicit MockEnvironment(const char **argv, const std::string &name = "default");
     ~MockEnvironment() override;
     void postCreate(lcb_INSTANCE *instance) const;
@@ -478,11 +490,47 @@ class MockEnvironment : public ::testing::Environment
     std::string userName;
     const char **argv_{nullptr};
     void clearAndReset();
+    TestTracer test_tracer;
+    TestMeter test_meter;
 
   private:
     lcb_INSTANCE *innerClient{nullptr};
 };
 
+class tracing_guard
+{
+  public:
+    tracing_guard()
+    {
+        was_enabled_ = MockEnvironment::getInstance()->getTracer().set_enabled(true);
+    }
+
+    ~tracing_guard()
+    {
+        MockEnvironment::getInstance()->getTracer().set_enabled(was_enabled_);
+    }
+
+  private:
+    bool was_enabled_{false};
+};
+
+class metrics_guard
+{
+  public:
+    metrics_guard()
+    {
+        was_enabled_ = MockEnvironment::getInstance()->getMeter().set_enabled(true);
+    }
+
+    ~metrics_guard()
+    {
+        MockEnvironment::getInstance()->getMeter().set_enabled(was_enabled_);
+    }
+
+  private:
+    bool was_enabled_{false};
+};
+
 #define LCB_TEST_REQUIRE_CLUSTER_VERSION(v)                                                                            \
     if (!MockEnvironment::getInstance()->isRealCluster()) {                                                            \
         MockEnvironment::printSkipMessage(__FILE__, __LINE__, "need real cluster");                                    \

package/deps/lcb/tests/iotests/mock-unit-test.cc

@@ -20,7 +20,7 @@
 
 #include "internal.h" /* vbucket_* things from lcb_INSTANCE **/
 #include <lcbio/iotable.h>
-#include "bucketconfig/bc_http.h"
+#include "libcouchbase/couchbase.h"
 
 #define LOGARGS(instance, lvl) instance->settings, "tests-MUT", LCB_LOG_##lvl, __FILE__, __LINE__
 
@@ -29,7 +29,7 @@
  */
 void MockUnitTest::SetUp()
 {
-    srand(time(NULL));
+    srand(time(nullptr));
     MockEnvironment::Reset();
 }
 
@@ -42,8 +42,8 @@ void checkConnectCommon(lcb_INSTANCE *instance)
 
 void MockUnitTest::createClusterConnection(HandleWrap &handle, lcb_INSTANCE **instance)
 {
-    lcb_CREATEOPTS *options = NULL;
-    MockEnvironment::getInstance()->makeConnectParams(options, NULL, LCB_TYPE_CLUSTER);
+    lcb_CREATEOPTS *options = nullptr;
+    MockEnvironment::getInstance()->makeConnectParams(options, nullptr, LCB_TYPE_CLUSTER);
     MockEnvironment::getInstance()->createConnection(handle, instance, options);
     checkConnectCommon(handle.getLcb());
     lcb_createopts_destroy(options);
@@ -70,7 +70,7 @@ void MockUnitTest::createConnection(lcb_INSTANCE **instance)
 
 void MockUnitTest::createConnection(HandleWrap &handle)
 {
-    lcb_INSTANCE *instance = NULL;
+    lcb_INSTANCE *instance = nullptr;
     createConnection(handle, &instance);
 }
 
@@ -81,3 +81,94 @@ lcb_STATUS MockUnitTest::tryCreateConnection(HandleWrap &hw, lcb_INSTANCE **inst
     lcb_wait(*instance, LCB_WAIT_DEFAULT);
     return lcb_get_bootstrap_status(*instance);
 }
+
+void MockUnitTest::assert_kv_span(const std::shared_ptr<TestSpan> &span, const std::string &expectedName,
+                                  const KVSpanAssertions &assertions)
+{
+    auto bucket = MockEnvironment::getInstance()->getBucket();
+    ASSERT_EQ(expectedName, span->name);
+    ASSERT_EQ("couchbase", span->str_tags["db.system"]);
+    ASSERT_TRUE(span->int_tags.find("db.couchbase.server_duration") != span->int_tags.end());
+    ASSERT_EQ(bucket, span->str_tags["db.name"]);
+    ASSERT_EQ(assertions.scope, span->str_tags["db.couchbase.scope"]);
+    ASSERT_EQ(assertions.collection, span->str_tags["db.couchbase.collection"]);
+    ASSERT_EQ("kv", span->str_tags["db.couchbase.service"]);
+    ASSERT_EQ(expectedName, span->str_tags["db.operation"]);
+    ASSERT_EQ("IP.TCP", span->str_tags["net.transport"]);
+    ASSERT_TRUE(span->str_tags.count("db.couchbase.operation_id") > 0);
+    ASSERT_TRUE(span->str_tags.count("db.couchbase.local_id") > 0);
+    ASSERT_TRUE(span->str_tags.count("net.host.name") > 0);
+    ASSERT_TRUE(span->str_tags.count("net.host.port") > 0);
+    ASSERT_TRUE(span->str_tags.count("net.peer.name") > 0);
+    ASSERT_TRUE(span->str_tags.count("net.peer.port") > 0);
+    ASSERT_TRUE(span->int_tags.count("db.couchbase.retries") > 0);
+    if (assertions.durability_level == LCB_DURABILITYLEVEL_NONE) {
+        ASSERT_TRUE(span->str_tags.count("db.couchbase.durability") == 0);
+    } else {
+        ASSERT_EQ(dur_level_to_string(assertions.durability_level), span->str_tags["db.couchbase.durability"]);
+    }
+    ASSERT_TRUE(span->finished);
+}
+
+void MockUnitTest::assert_http_span(const std::shared_ptr<TestSpan> &span, const std::string &expectedName,
+                                    const HTTPSpanAssertions &assertions)
+{
+    ASSERT_EQ(expectedName, span->name);
+    ASSERT_EQ("couchbase", span->str_tags["db.system"]);
+    if (!assertions.bucket.empty()) {
+        ASSERT_EQ(assertions.bucket, span->str_tags["db.name"]);
+    }
+    if (!assertions.scope.empty()) {
+        ASSERT_EQ(assertions.scope, span->str_tags["db.couchbase.scope"]);
+    }
+    if (!assertions.collection.empty()) {
+        ASSERT_EQ(assertions.collection, span->str_tags["db.couchbase.collection"]);
+    }
+    if (!assertions.service.empty()) {
+        ASSERT_EQ(assertions.service, span->str_tags["db.couchbase.service"]);
+    }
+    if (!assertions.op.empty()) {
+        ASSERT_EQ(assertions.op, span->str_tags["db.operation"]);
+    }
+    ASSERT_EQ("IP.TCP", span->str_tags["net.transport"]);
+    if (assertions.operation_id.empty()) {
+        ASSERT_TRUE(span->str_tags.find("db.couchbase.operation_id") == span->str_tags.end());
+    } else if (assertions.operation_id == "any") {
+        ASSERT_TRUE(span->str_tags.find("db.couchbase.operation_id") != span->str_tags.end());
+    } else {
+        ASSERT_EQ(assertions.operation_id, span->str_tags["db.couchbase.operation_id"]);
+    }
+    ASSERT_TRUE(span->str_tags.find("net.host.name") != span->str_tags.end());
+    ASSERT_TRUE(span->str_tags.find("net.host.port") != span->str_tags.end());
+    ASSERT_TRUE(span->str_tags.find("net.peer.name") != span->str_tags.end());
+    ASSERT_TRUE(span->str_tags.find("net.peer.port") != span->str_tags.end());
+    ASSERT_TRUE(span->int_tags.find("db.couchbase.retries") != span->int_tags.end());
+    if (!assertions.statement.empty()) {
+        ASSERT_EQ(assertions.statement, span->str_tags["db.statement"]);
+    }
+    ASSERT_TRUE(span->finished);
+}
+
+void MockUnitTest::assert_kv_metrics(const std::string &metric_name, const std::string &op, uint32_t length,
+                                     bool at_least_len)
+{
+    std::string key = metric_name + ":kv";
+    if (op != "") {
+        key = key + ":" + op;
+    }
+    assert_metrics(key, length, at_least_len);
+}
+
+void MockUnitTest::assert_metrics(const std::string &key, uint32_t length, bool at_least_len)
+{
+    auto meter = MockEnvironment::getInstance()->getMeter();
+    ASSERT_TRUE(meter.recorders.find(key) != meter.recorders.end());
+    if (at_least_len) {
+        ASSERT_TRUE(meter.recorders[key]->values.size() >= length);
+    } else {
+        ASSERT_TRUE(meter.recorders[key]->values.size() == length);
+    }
+    for (const auto value : meter.recorders[key]->values) {
+        ASSERT_NE(0, value);
+    }
+}

package/deps/lcb/tests/iotests/mock-unit-test.h

@@ -21,6 +21,7 @@
 #include <gtest/gtest.h>
 #include <libcouchbase/couchbase.h>
 #include "mock-environment.h"
+#include "testutil.h"
 
 class HandleWrap;
 
@@ -44,6 +45,22 @@ class HandleWrap;
         return;                                                                                                        \
     }
 
+struct KVSpanAssertions {
+    lcb_DURABILITY_LEVEL durability_level{LCB_DURABILITYLEVEL_NONE};
+    std::string scope{"_default"};
+    std::string collection{"_default"};
+};
+
+struct HTTPSpanAssertions {
+    std::string statement{};
+    std::string scope{};
+    std::string collection{};
+    std::string bucket{};
+    std::string op{};
+    std::string operation_id{};
+    std::string service{};
+};
+
 class MockUnitTest : public ::testing::Test
 {
   protected:
@@ -56,6 +73,13 @@ class MockUnitTest : public ::testing::Test
     virtual void createClusterConnection(HandleWrap &handle, lcb_INSTANCE **instance);
     virtual lcb_STATUS tryCreateConnection(HandleWrap &hw, lcb_INSTANCE **instance, lcb_CREATEOPTS *&crparams);
 
+    static void assert_kv_span(const std::shared_ptr<TestSpan> &span, const std::string &expectedName,
+                               const KVSpanAssertions &assertions);
+    static void assert_http_span(const std::shared_ptr<TestSpan> &span, const std::string &expectedName,
+                                 const HTTPSpanAssertions &assertions);
+    void assert_kv_metrics(const std::string &metric_name, const std::string &op, uint32_t length, bool at_least_len);
+    void assert_metrics(const std::string &key, uint32_t length, bool at_least_len);
+
     // A mock "Transaction"
     void doMockTxn(MockCommand &cmd)
     {
@@ -66,4 +90,12 @@ class MockUnitTest : public ::testing::Test
     }
 };
 
+/*
+ * This test class groups tests that might be problematic when executed together with all other tests.
+ * Every test case in this suite must start with Jira ticket number for future.
+ */
+class ContaminatingUnitTest : public MockUnitTest
+{
+};
+
 #endif

package/deps/lcb/tests/iotests/serverparams.h

@@ -37,10 +37,15 @@ class ServerParams
     void makeConnectParams(lcb_CREATEOPTS *&crst, lcb_io_opt_t io, lcb_INSTANCE_TYPE type = LCB_TYPE_BUCKET)
     {
         lcb_createopts_create(&crst, type);
-        if (host.find("couchbase://") == 0) {
+        if (host.find("couchbase") == 0) {
             connstr = host;
             // deactivate dnssrv and compression, use cccp bootstrap
-            connstr += "?dnssrv=off&bootstrap_on=cccp&compression=off";
+            if (host.find("?") == std::string::npos) {
+                connstr += "?";
+            } else {
+                connstr += "&";
+            }
+            connstr += "dnssrv=off&bootstrap_on=cccp&compression=off";
         } else {
             if (mcNodes.empty() || type == LCB_TYPE_CLUSTER) {
                 connstr = "couchbase://" + host + "=http";

package/deps/lcb/tests/iotests/t_collections.cc

@@ -572,7 +572,7 @@ TEST_F(CollectionUnitTest, testDroppedScope)
  *
  * Collection creations are successful
  */
-TEST_F(CollectionUnitTest, testMaxCollectionsPerScope)
+TEST_F(ContaminatingUnitTest, test_CCBC_1483_MaxCollectionsPerScope)
 {
     SKIP_IF_MOCK()
     SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(MockEnvironment::VERSION_70)

package/deps/lcb/tests/iotests/t_confmon.cc

@@ -24,6 +24,9 @@ struct evstop_listener : Listener {
 
     void clconfig_lsn(EventType event, ConfigInfo *)
     {
+        if (event == CLCONFIG_EVENT_PROVIDERS_CYCLED) {
+            return IOT_STOP(io);
+        }
         if (event != CLCONFIG_EVENT_GOT_NEW_CONFIG) {
             return;
         }
@@ -40,7 +43,6 @@ static void listen_callback1(Listener *lsn, EventType event, ConfigInfo *info) {
 
 TEST_F(ConfmonTest, testBasic)
 {
-    SKIP_UNLESS_MOCK();
     HandleWrap hw;
     lcb_INSTANCE *instance;
     MockEnvironment::getInstance()->createConnection(hw, &instance);
@@ -68,8 +70,8 @@ TEST_F(ConfmonTest, testBasic)
     mon->start();
 
     IOT_START(instance->iotable);
-    ASSERT_NE(0, listener.called);
     delete mon;
+    ASSERT_NE(0, listener.called);
 }
 
 struct listener2 : Listener {

package/deps/lcb/tests/iotests/t_get.cc

@@ -21,6 +21,7 @@
 #include "iotests.h"
 #include "logging.h"
 #include "internal.h"
+#include "testutil.h"
 
 #define LOGARGS(instance, lvl) instance->settings, "tests-GET", LCB_LOG_##lvl, __FILE__, __LINE__
 
@@ -106,6 +107,9 @@ static void testGetHitGetCallback(lcb_INSTANCE *, lcb_CALLBACK_TYPE, const lcb_R
  */
 TEST_F(GetUnitTest, testGetHit)
 {
+    MockEnvironment *mock = MockEnvironment::getInstance();
+    tracing_guard use_tracing;
+    metrics_guard use_metrics;
     HandleWrap hw;
     lcb_INSTANCE *instance;
     createConnection(hw, &instance);
@@ -129,6 +133,16 @@ TEST_F(GetUnitTest, testGetHit)
 
     lcb_wait(instance, LCB_WAIT_DEFAULT);
     EXPECT_EQ(2, numcallbacks);
+
+    auto spans = mock->getTracer().spans;
+    ASSERT_EQ(4, spans.size());
+    auto span = spans[0];
+    assert_kv_span(span, "upsert", {});
+    span = spans[2];
+    assert_kv_span(span, "get", {});
+
+    assert_kv_metrics(METRICS_OPS_METER_NAME, "get", 2, false);
+    assert_kv_metrics(METRICS_OPS_METER_NAME, "upsert", 2, false);
 }
 
 extern "C" {
@@ -1097,10 +1111,6 @@ TEST_F(GetUnitTest, testChangePassword)
     createConnection(hwHttp, &instanceHttp);
     (void)lcb_install_callback(instanceHttp, LCB_CALLBACK_HTTP, (lcb_RESPCALLBACK)change_password_http_callback);
 
-    // Set short timeout
-    lcb_uint32_t tmoval = 100000;
-    lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_OP_TIMEOUT, &tmoval);
-
     // store keys
     // run one set to connect to only one node
     // the goal is to change the password then try to connect others nodes

package/deps/lcb/tests/iotests/t_n1ql.cc

@@ -165,6 +165,8 @@ class QueryUnitTest : public MockUnitTest
 
 TEST_F(QueryUnitTest, testSimple)
 {
+    MockEnvironment *mock = MockEnvironment::getInstance();
+    tracing_guard use_tracing;
     lcb_INSTANCE *instance;
     HandleWrap hw;
     if (!createQueryConnection(hw, &instance)) {
@@ -172,12 +174,26 @@ TEST_F(QueryUnitTest, testSimple)
     }
 
     N1QLResult res;
-    makeCommand("SELECT mockrow");
+    const char *query = "SELECT mockrow";
+    makeCommand(query);
+
+    const char *context_id = "context_id";
+    lcb_cmdquery_client_context_id(cmd, context_id, strlen(context_id));
+
     lcb_STATUS rc = lcb_query(instance, &res, cmd);
     ASSERT_STATUS_EQ(LCB_SUCCESS, rc);
     lcb_wait(instance, LCB_WAIT_DEFAULT);
     ASSERT_STATUS_EQ(LCB_SUCCESS, res.rc);
     ASSERT_EQ(1, res.rows.size());
+
+    auto spans = mock->getTracer().spans;
+    ASSERT_EQ(1, spans.size());
+    auto span = spans[0];
+    HTTPSpanAssertions assertions;
+    assertions.statement = query;
+    assertions.operation_id = context_id;
+    assertions.service = "query";
+    assert_http_span(span, "query", assertions);
 }
 
 TEST_F(QueryUnitTest, testQueryError)