couchbase 3.2.3 → 3.2.4

package/deps/lcb/src/tracing/tracing-internal.h

@@ -26,6 +26,13 @@
 #include <queue>
 #include <map>
 #include <string>
+#include <memory>
+
+LCB_INTERNAL_API
+void lcbtrace_span_add_system_tags(lcbtrace_SPAN *span, const lcb_settings *settings, lcbtrace_THRESHOLDOPTS svc);
+LIBCOUCHBASE_API
+void lcbtrace_span_add_tag_str_nocopy(lcbtrace_SPAN *span, const char *name, const char *value);
+void lcbtrace_span_add_host_and_port(lcbtrace_SPAN *span, lcbio_CONNINFO *info);
 
 namespace lcb
 {
@@ -45,6 +52,7 @@ class Span
         return m_finish - m_start;
     }
 
+    void add_tag(const char *name, const std::string &value);
     void add_tag(const char *name, int copy, const char *value, int copy_value);
     void add_tag(const char *name, int copy_key, const char *value, size_t value_len, int copy_value);
     void add_tag(const char *name, int copy, uint64_t value);
@@ -141,7 +149,7 @@ class ThresholdLoggingTracer
     QueueEntry convert(lcbtrace_SPAN *span);
 
   public:
-    ThresholdLoggingTracer(lcb_INSTANCE *instance);
+    explicit ThresholdLoggingTracer(lcb_INSTANCE *instance);
 
     lcbtrace_TRACER *wrap();
     void add_orphan(lcbtrace_SPAN *span);
@@ -156,108 +164,112 @@ class ThresholdLoggingTracer
     lcb::io::Timer<ThresholdLoggingTracer, &ThresholdLoggingTracer::flush_threshold> m_tflush;
 };
 
-} // namespace trace
-} // namespace lcb
-
-extern "C" {
-#endif /* __cplusplus */
-LCB_INTERNAL_API
-void lcbtrace_span_add_system_tags(lcbtrace_SPAN *span, lcb_settings *settings, lcbtrace_THRESHOLDOPTS svc);
-LCB_INTERNAL_API
-void lcbtrace_span_set_parent(lcbtrace_SPAN *span, lcbtrace_SPAN *parent);
-LCB_INTERNAL_API
-void lcbtrace_span_set_orphaned(lcbtrace_SPAN *span, int val);
-LIBCOUCHBASE_API
-void lcbtrace_span_add_tag_str_nocopy(lcbtrace_SPAN *span, const char *name, const char *value);
-
-const char *dur_level_to_string(lcb_DURABILITY_LEVEL dur_level);
-void lcbtrace_span_add_host_and_port(lcbtrace_SPAN *span, lcbio_CONNINFO *info);
-#ifdef __cplusplus
-#define LCBTRACE_ADD_RETRIES(span, retries)                                                                            \
-    if (span) {                                                                                                        \
-        span->find_outer_or_this()->add_tag(LCBTRACE_TAG_RETRIES, 0, (uint64_t)retries);                               \
+template <typename COMMAND>
+lcbtrace_SPAN *start_kv_span(const lcb_settings *settings, const mc_PACKET *packet, std::shared_ptr<COMMAND> cmd)
+{
+    if (settings == nullptr || settings->tracer == nullptr) {
+        return nullptr;
+    }
+    lcbtrace_SPAN *span;
+    lcbtrace_SPAN *parent_span = cmd->parent_span();
+    if (parent_span != nullptr && parent_span->is_outer() && settings->tracer->flags & LCBTRACE_F_THRESHOLD) {
+        span = parent_span;
+        span->should_finish(false);
+    } else {
+        lcbtrace_REF ref;
+        ref.type = LCBTRACE_REF_CHILD_OF;
+        ref.span = parent_span;
+        bool is_dispatch = (parent_span != nullptr && parent_span->is_outer());
+        span = lcbtrace_span_start((settings)->tracer,
+                                   is_dispatch ? LCBTRACE_OP_DISPATCH_TO_SERVER : cmd->operation_name().c_str(),
+                                   LCBTRACE_NOW, &ref);
+        span->should_finish(true);
+        span->is_outer(!is_dispatch);
     }
+    span->is_dispatch(true);
+    std::string operation_id = std::to_string(packet->opaque);
+    lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_OPERATION_ID, operation_id.c_str());
+    lcbtrace_span_add_system_tags(span, settings, LCBTRACE_THRESHOLD_KV);
+    span->add_tag(LCBTRACE_TAG_SCOPE, cmd->collection().scope());
+    span->add_tag(LCBTRACE_TAG_COLLECTION, cmd->collection().collection());
+    span->add_tag(LCBTRACE_TAG_OPERATION, cmd->operation_name());
+    return span;
+}
 
-// called by lcb_query, etc...  The underlying lcb_http call will fill in the dispatch span tags
-#define LCBTRACE_HTTP_START(settings, opaque, pspan, operation_name, svc, outspan)                                     \
-    LCBTRACE_START(settings, opaque, pspan, operation_name, svc, outspan)
+void finish_kv_span(const mc_PIPELINE *pipeline, const mc_PACKET *request_pkt, const MemcachedResponse *response_pkt);
 
-#define LCBTRACE_KV_START(settings, opaque, cmd, operation_name, outspan)                                              \
-    if (nullptr != (settings)->tracer) {                                                                               \
-        lcbtrace_SPAN *pspan = cmd->parent_span();                                                                     \
-        char opid[20] = {};                                                                                            \
-        snprintf(opid, sizeof(opid), "%p", reinterpret_cast<void *>(opaque));                                          \
-        LCBTRACE_START(settings, opid, pspan, operation_name, LCBTRACE_THRESHOLD_KV, outspan)                          \
+template <typename COMMAND>
+lcbtrace_SPAN *start_kv_span_with_durability(const lcb_settings *settings, const mc_PACKET *packet,
+                                             std::shared_ptr<COMMAND> cmd)
+{
+    lcbtrace_SPAN *span = start_kv_span(settings, packet, cmd);
+    if (span != nullptr && cmd->durability_level() != LCB_DURABILITYLEVEL_NONE) {
+        span->add_tag(LCBTRACE_TAG_DURABILITY, 0, dur_level_to_string(cmd->durability_level()), 0);
     }
+    return span;
+}
 
-// don't create a span if passed an outer parent, if we are the threshold logger,
-// and use its close to determine times, etc...
-#define LCBTRACE_START(settings, opaque, pspan, operation_name, svc, outspan)                                          \
-    if (nullptr != (settings)->tracer) {                                                                               \
-        if (nullptr != pspan && pspan->is_outer() && (settings)->tracer->flags & LCBTRACE_F_THRESHOLD) {               \
-            outspan = pspan;                                                                                           \
-            outspan->should_finish(false);                                                                             \
-        } else {                                                                                                       \
-            lcbtrace_REF ref;                                                                                          \
-            ref.type = LCBTRACE_REF_CHILD_OF;                                                                          \
-            ref.span = pspan;                                                                                          \
-            bool is_dispatch = (pspan && pspan->is_outer());                                                           \
-            outspan =                                                                                                  \
-                lcbtrace_span_start((settings)->tracer, is_dispatch ? LCBTRACE_OP_DISPATCH_TO_SERVER : operation_name, \
-                                    LCBTRACE_NOW, &ref);                                                               \
-            outspan->should_finish(true);                                                                              \
-            outspan->is_outer(!is_dispatch);                                                                           \
-        }                                                                                                              \
-        outspan->is_dispatch(true);                                                                                    \
-        if (opaque) {                                                                                                  \
-            lcbtrace_span_add_tag_str(outspan, LCBTRACE_TAG_OPERATION_ID, opaque);                                     \
-        }                                                                                                              \
-        lcbtrace_span_add_system_tags(outspan, settings, svc);                                                         \
-    } else {                                                                                                           \
-        outspan = nullptr;                                                                                             \
+template <typename COMMAND>
+lcbtrace_SPAN *start_http_span(const lcb_settings *settings, const COMMAND *cmd)
+{
+    if (settings == nullptr || settings->tracer == nullptr) {
+        return nullptr;
+    }
+    lcbtrace_SPAN *span;
+    lcbtrace_SPAN *parent_span = cmd->parent_span();
+    if (parent_span != nullptr && parent_span->is_outer() && settings->tracer->flags & LCBTRACE_F_THRESHOLD) {
+        span = parent_span;
+        span->should_finish(false);
+    } else {
+        lcbtrace_REF ref;
+        ref.type = LCBTRACE_REF_CHILD_OF;
+        ref.span = parent_span;
+        bool is_dispatch = (parent_span != nullptr && parent_span->is_outer());
+        span = lcbtrace_span_start((settings)->tracer,
+                                   is_dispatch ? LCBTRACE_OP_DISPATCH_TO_SERVER : cmd->operation_name().c_str(),
+                                   LCBTRACE_NOW, &ref);
+        span->should_finish(true);
+        span->is_outer(!is_dispatch);
     }
+    span->is_dispatch(true);
+    lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_OPERATION_ID, cmd->client_context_id().c_str());
+    lcbtrace_span_add_system_tags(span, settings, cmd->service());
+    span->add_tag(LCBTRACE_TAG_OPERATION, cmd->operation_name());
+    return span;
+}
 
-#define LCBTRACE_KVSTORE_START(settings, opaque, cmd, operation_name, outspan)                                         \
-    LCBTRACE_KV_START(settings, opaque, cmd, operation_name, outspan)                                                  \
-    if ((settings)->tracer) {                                                                                          \
-        outspan->add_tag(LCBTRACE_TAG_DURABILITY, 0, dur_level_to_string(cmd->durability_level()), 0);                 \
+template <typename COMMAND>
+lcbtrace_SPAN *start_http_span_with_statement(const lcb_settings *settings, const COMMAND *cmd,
+                                              const std::string &statement)
+{
+    lcbtrace_SPAN *span = start_http_span(settings, cmd);
+    if (span != nullptr && !statement.empty()) {
+        span->add_tag(LCBTRACE_TAG_STATEMENT, statement);
     }
+    return span;
+}
 
-#define LCBTRACE_KV_FINISH(pipeline, request, resp, server_duration)                                                   \
-    do {                                                                                                               \
-        lcbtrace_SPAN *dispatch_span__ = MCREQ_PKT_RDATA(request)->span;                                               \
-        if (dispatch_span__) {                                                                                         \
-            dispatch_span__->increment_server(server_duration);                                                        \
-            lcb::Server *server = static_cast<lcb::Server *>(pipeline);                                                \
-            dispatch_span__->find_outer_or_this()->add_tag(LCBTRACE_TAG_RETRIES, 0, (uint64_t)request->retries);       \
-            lcbtrace_span_add_tag_str_nocopy(dispatch_span__, LCBTRACE_TAG_TRANSPORT, "IP.TCP");                       \
-            lcbio_CTX *ctx = server->connctx;                                                                          \
-            if (ctx) {                                                                                                 \
-                char local_id[34] = {};                                                                                \
-                snprintf(local_id, sizeof(local_id), "%016" PRIx64 "/%016" PRIx64,                                     \
-                         (uint64_t)server->get_settings()->iid, (uint64_t)ctx->sock->id);                              \
-                lcbtrace_span_add_tag_str(dispatch_span__, LCBTRACE_TAG_LOCAL_ID, local_id);                           \
-                lcbtrace_span_add_host_and_port(dispatch_span__, ctx->sock->info);                                     \
-            }                                                                                                          \
-            if (dispatch_span__->should_finish()) {                                                                    \
-                lcbtrace_span_finish(dispatch_span__, LCBTRACE_NOW);                                                   \
-            }                                                                                                          \
-        }                                                                                                              \
-    } while (0)
-
-#define LCBTRACE_HTTP_FINISH(span)                                                                                     \
-    if (nullptr != span) {                                                                                             \
-        lcbtrace_span_add_tag_str_nocopy(span, LCBTRACE_TAG_TRANSPORT, "IP.TCP");                                      \
-        if (span->should_finish()) {                                                                                   \
-            lcbtrace_span_finish(span, LCBTRACE_NOW);                                                                  \
-        }                                                                                                              \
-        span = nullptr;                                                                                                \
+template <typename COMMAND>
+void finish_http_span(lcbtrace_SPAN *span, const COMMAND *cmd)
+{
+    if (span != nullptr) {
+        span->find_outer_or_this()->add_tag(LCBTRACE_TAG_RETRIES, 0, (uint64_t)cmd->retries());
+        if (span->should_finish()) {
+            lcbtrace_span_finish(span, LCBTRACE_NOW);
+        }
     }
 }
-#else
-#define LCBTRACE_KVSTORE_START(settings, opaque, cmd, operation_name, outspan)
-#define LCBTRACE_HTTP_START(settings, opaque, pspan, operation_name, svc, outspan)
-#define LCBTRACE_KV_FINISH(pipeline, request, server_duration)
-#define LCBTRACE_HTTP_FINISH(span)
+
+} // namespace trace
+} // namespace lcb
+
+extern "C" {
+#endif /* __cplusplus */
+LCB_INTERNAL_API
+void lcbtrace_span_set_orphaned(lcbtrace_SPAN *span, int val);
+
+const char *dur_level_to_string(lcb_DURABILITY_LEVEL dur_level);
+#ifdef __cplusplus
+}
 #endif /* __cplusplus*/
 #endif /* LCB_TRACING_INTERNAL_H */

package/deps/lcb/src/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/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);
@@ -556,6 +568,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"
@@ -451,6 +452,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 +489,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");                                    \