couchbase 4.1.1 → 4.1.3

package/deps/couchbase-transactions-cxx/src/transactions/transaction_context.cxx

@@ -100,7 +100,7 @@ namespace transactions
         return current_attempt_context_;
     }
 
-    void transaction_context::get(const couchbase::document_id& id, async_attempt_context::Callback&& cb)
+    void transaction_context::get(const core::document_id& id, async_attempt_context::Callback&& cb)
     {
         if (current_attempt_context_) {
             return current_attempt_context_->get(id, std::move(cb));
@@ -108,7 +108,7 @@ namespace transactions
         throw transaction_operation_failed(FAIL_OTHER, "no current attempt context");
     }
 
-    void transaction_context::get_optional(const couchbase::document_id& id, async_attempt_context::Callback&& cb)
+    void transaction_context::get_optional(const core::document_id& id, async_attempt_context::Callback&& cb)
     {
         if (current_attempt_context_) {
             return current_attempt_context_->get_optional(id, std::move(cb));
@@ -116,7 +116,7 @@ namespace transactions
         throw transaction_operation_failed(FAIL_OTHER, "no current attempt context");
     }
 
-    void transaction_context::insert(const couchbase::document_id& id, const std::string& content, async_attempt_context::Callback&& cb)
+    void transaction_context::insert(const core::document_id& id, const std::string& content, async_attempt_context::Callback&& cb)
     {
         if (current_attempt_context_) {
             return current_attempt_context_->insert_raw(id, content, std::move(cb));

package/deps/couchbase-transactions-cxx/src/transactions/transaction_get_result.cxx

@@ -19,7 +19,7 @@
 namespace couchbase::transactions
 {
 transaction_get_result
-transaction_get_result::create_from(const couchbase::operations::lookup_in_response& resp)
+transaction_get_result::create_from(const core::operations::lookup_in_response& resp)
 {
     std::optional<std::string> atr_id;
     std::optional<std::string> transaction_id;
@@ -45,56 +45,56 @@ transaction_get_result::create_from(const couchbase::operations::lookup_in_respo
     std::optional<std::string> op;
     std::string content;
 
-    if (resp.fields[0].status == protocol::status::success) {
-        atr_id = default_json_serializer::deserialize_from_json_string<std::string>(resp.fields[0].value);
+    if (resp.fields[0].status == key_value_status_code::success) {
+        atr_id = default_json_serializer::deserialize_from_json_string<std::string>(to_string(resp.fields[0].value));
     }
-    if (resp.fields[1].status == protocol::status::success) {
-        transaction_id = default_json_serializer::deserialize_from_json_string<std::string>(resp.fields[1].value);
+    if (resp.fields[1].status == key_value_status_code::success) {
+        transaction_id = default_json_serializer::deserialize_from_json_string<std::string>(to_string(resp.fields[1].value));
     }
-    if (resp.fields[2].status == protocol::status::success) {
-        attempt_id = default_json_serializer::deserialize_from_json_string<std::string>(resp.fields[2].value);
+    if (resp.fields[2].status == key_value_status_code::success) {
+        attempt_id = default_json_serializer::deserialize_from_json_string<std::string>(to_string(resp.fields[2].value));
     }
-    if (resp.fields[3].status == protocol::status::success) {
-        staged_content = resp.fields[3].value;
+    if (resp.fields[3].status == key_value_status_code::success) {
+        staged_content = to_string(resp.fields[3].value);
     }
-    if (resp.fields[4].status == protocol::status::success) {
-        atr_bucket_name = default_json_serializer::deserialize_from_json_string<std::string>(resp.fields[4].value);
+    if (resp.fields[4].status == key_value_status_code::success) {
+        atr_bucket_name = default_json_serializer::deserialize_from_json_string<std::string>(to_string(resp.fields[4].value));
     }
-    if (resp.fields[5].status == protocol::status::success) {
-        atr_scope_name = default_json_serializer::deserialize_from_json_string<std::string>(resp.fields[5].value);
+    if (resp.fields[5].status == key_value_status_code::success) {
+        atr_scope_name = default_json_serializer::deserialize_from_json_string<std::string>(to_string(resp.fields[5].value));
     }
-    if (resp.fields[6].status == protocol::status::success) {
-        atr_collection_name = default_json_serializer::deserialize_from_json_string<std::string>(resp.fields[6].value);
+    if (resp.fields[6].status == key_value_status_code::success) {
+        atr_collection_name = default_json_serializer::deserialize_from_json_string<std::string>(to_string(resp.fields[6].value));
     }
 
-    if (resp.fields[7].status == protocol::status::success) {
-        auto restore = nlohmann::json::parse(resp.fields[7].value);
+    if (resp.fields[7].status == key_value_status_code::success) {
+        auto restore = nlohmann::json::parse(to_string(resp.fields[7].value));
         cas_pre_txn = restore["CAS"].get<std::string>();
         // only present in 6.5+
         revid_pre_txn = restore["revid"].get<std::string>();
         exptime_pre_txn = restore["exptime"].get<uint32_t>();
     }
-    if (resp.fields[8].status == protocol::status::success) {
-        op = default_json_serializer::deserialize_from_json_string<std::string>(resp.fields[8].value);
+    if (resp.fields[8].status == key_value_status_code::success) {
+        op = default_json_serializer::deserialize_from_json_string<std::string>(to_string(resp.fields[8].value));
     }
-    if (resp.fields[9].status == protocol::status::success) {
-        auto doc = nlohmann::json::parse(resp.fields[9].value);
+    if (resp.fields[9].status == key_value_status_code::success) {
+        auto doc = nlohmann::json::parse(to_string(resp.fields[9].value));
         cas_from_doc = doc["CAS"].get<std::string>();
         // only present in 6.5+
         revid_from_doc = doc["revid"].get<std::string>();
         exptime_from_doc = doc["exptime"].get<uint32_t>();
         crc32_from_doc = doc["value_crc32c"].get<std::string>();
     }
-    if (resp.fields[10].status == protocol::status::success) {
-        crc32_of_staging = default_json_serializer::deserialize_from_json_string<std::string>(resp.fields[10].value);
+    if (resp.fields[10].status == key_value_status_code::success) {
+        crc32_of_staging = default_json_serializer::deserialize_from_json_string<std::string>(to_string(resp.fields[10].value));
     }
-    if (resp.fields[11].status == protocol::status::success) {
-        forward_compat = nlohmann::json::parse(resp.fields[11].value);
+    if (resp.fields[11].status == key_value_status_code::success) {
+        forward_compat = nlohmann::json::parse(to_string(resp.fields[11].value));
     } else {
         forward_compat = nlohmann::json::object();
     }
-    if (resp.fields[12].status == protocol::status::success) {
-        content = resp.fields[12].value;
+    if (resp.fields[12].status == key_value_status_code::success) {
+        content = to_string(resp.fields[12].value);
     }
 
     transaction_links links(atr_id,
@@ -112,11 +112,15 @@ transaction_get_result::create_from(const couchbase::operations::lookup_in_respo
                             forward_compat,
                             resp.deleted);
     document_metadata md(cas_from_doc, revid_from_doc, exptime_from_doc, crc32_from_doc);
-    return { resp.ctx.id, content, resp.cas.value, links, std::make_optional(md) };
+    return { { resp.ctx.bucket(), resp.ctx.scope(), resp.ctx.collection(), resp.ctx.id() },
+             content,
+             resp.cas.value(),
+             links,
+             std::make_optional(md) };
 }
 
 transaction_get_result
-transaction_get_result::create_from(const couchbase::document_id& id, const result& res)
+transaction_get_result::create_from(const core::document_id& id, const result& res)
 {
     std::optional<std::string> atr_id;
     std::optional<std::string> transaction_id;

package/deps/couchbase-transactions-cxx/src/transactions/transaction_query_options.cxx

@@ -19,14 +19,14 @@
 namespace couchbase::transactions
 {
 
-couchbase::operations::query_request
+core::operations::query_request
 transaction_query_options::wrap_request(const couchbase::transactions::transaction_context& txn_context) const
 {
     // set timeout stuff using the config/context.
     // extra time so we don't timeout right at expiry.
-    auto extra = txn_context.config().kv_timeout() ? txn_context.config().kv_timeout().value()
-                                                   : couchbase::timeout_defaults::key_value_durable_timeout;
-    couchbase::operations::query_request req = query_req_;
+    auto extra =
+      txn_context.config().kv_timeout() ? txn_context.config().kv_timeout().value() : core::timeout_defaults::key_value_durable_timeout;
+    core::operations::query_request req = query_req_;
     if (!req.scan_consistency) {
         req.scan_consistency = txn_context.config().scan_consistency();
     }

package/deps/couchbase-transactions-cxx/src/transactions/transactions.cxx

@@ -24,12 +24,36 @@
 
 namespace tx = couchbase::transactions;
 
-tx::transactions::transactions(cluster& cluster, const transaction_config& config)
+tx::transactions::transactions(core::cluster& cluster, const transaction_config& config)
   : cluster_(cluster)
   , config_(config)
   , cleanup_(new transactions_cleanup(cluster_, config_))
 {
     txn_log->info("couchbase transactions {}{} creating new transaction object", VERSION_STR, VERSION_SHA);
+    // if the config specifies custom metadata collection, lets be sure to open that bucket
+    // on the cluster before we start.  NOTE: we actually do call get_and_open_buckets which opens all the buckets
+    // on the cluster (that we have permissions to open) in the cleanup.   However, that is happening asynchronously
+    // so there's a chance we will fail to have opened the custom metadata collection bucket before trying to make a
+    // transaction.   We have to open this one _now_.
+    if (config_.custom_metadata_collection()) {
+        auto barrier = std::make_shared<std::promise<std::error_code>>();
+        auto f = barrier->get_future();
+        std::atomic<bool> callback_called{ false };
+        cluster_.open_bucket(config_.custom_metadata_collection()->bucket, [&callback_called, barrier](std::error_code ec) {
+            if (callback_called.load()) {
+                return;
+            }
+            callback_called = true;
+            barrier->set_value(ec);
+        });
+        auto err = f.get();
+        if (err) {
+            auto err_msg = fmt::format("error opening custom_metadata_collection bucket '{}' specified in the config!",
+                                       config_.custom_metadata_collection()->bucket);
+            txn_log->error(err_msg);
+            throw std::runtime_error(err_msg);
+        }
+    }
 }
 
 tx::transactions::~transactions() = default;

package/deps/couchbase-transactions-cxx/src/transactions/transactions_cleanup.cxx

@@ -14,9 +14,6 @@
  *   limitations under the License.
  */
 
-#include <algorithm>
-#include <chrono>
-#include <functional>
 #include "active_transaction_record.hxx"
 #include "atr_ids.hxx"
 #include "attempt_context_impl.hxx"
@@ -28,6 +25,10 @@
 #include "couchbase/transactions/internal/utils.hxx"
 #include "uid_generator.hxx"
 
+#include <algorithm>
+#include <chrono>
+#include <functional>
+
 namespace tx = couchbase::transactions;
 
 tx::transactions_cleanup_attempt::transactions_cleanup_attempt(const tx::atr_cleanup_entry& entry)
@@ -38,7 +39,7 @@ tx::transactions_cleanup_attempt::transactions_cleanup_attempt(const tx::atr_cle
 {
 }
 
-tx::transactions_cleanup::transactions_cleanup(couchbase::cluster& cluster, const tx::transaction_config& config)
+tx::transactions_cleanup::transactions_cleanup(core::cluster& cluster, const tx::transaction_config& config)
   : cluster_(cluster)
   , config_(config)
   , client_uuid_(uid_generator::next())
@@ -185,7 +186,7 @@ tx::transactions_cleanup::clean_lost_attempts_in_bucket(const std::string& bucke
 }
 
 const tx::atr_cleanup_stats
-tx::transactions_cleanup::handle_atr_cleanup(const couchbase::document_id& atr_id, std::vector<transactions_cleanup_attempt>* results)
+tx::transactions_cleanup::handle_atr_cleanup(const core::document_id& atr_id, std::vector<transactions_cleanup_attempt>* results)
 {
     atr_cleanup_stats stats;
     auto atr = active_transaction_record::get_atr(cluster_, atr_id);
@@ -223,11 +224,16 @@ tx::transactions_cleanup::create_client_record(const std::string& bucket_name)
 {
     try {
         auto id = config_.atr_id_from_bucket_and_key(bucket_name, CLIENT_RECORD_DOC_ID);
-        couchbase::operations::mutate_in_request req{ id };
-        req.store_semantics = protocol::mutate_in_request_body::store_semantics_type::insert;
-        req.specs.add_spec(protocol::subdoc_opcode::dict_add, true, true, false, FIELD_CLIENTS, "{}");
-        // ExtBinaryMetadata
-        req.specs.add_spec(protocol::subdoc_opcode::set_doc, false, false, false, std::string(""), jsonify(std::string({ 0x00 })));
+        core::operations::mutate_in_request req{ id };
+        req.store_semantics = couchbase::store_semantics::insert;
+        req.specs =
+          couchbase::mutate_in_specs{
+              couchbase::mutate_in_specs::insert(FIELD_CLIENTS, tao::json::empty_object).xattr().create_path(),
+              // subdoc::opcode::set_doc used in replace w/ empty path
+              // ExtBinaryMetadata
+              couchbase::mutate_in_specs::replace({}, std::string({ 0x00 })),
+          }
+            .specs();
         wrap_durable_request(req, config_);
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
@@ -235,9 +241,8 @@ tx::transactions_cleanup::create_client_record(const std::string& bucket_name)
         if (ec) {
             throw client_error(*ec, "client_record_before_create hook raised error");
         }
-        cluster_.execute(req, [barrier](couchbase::operations::mutate_in_response resp) {
-            barrier->set_value(result::create_from_subdoc_response(resp));
-        });
+        cluster_.execute(
+          req, [barrier](core::operations::mutate_in_response resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
         wrap_operation_future(f);
 
     } catch (const tx::client_error& e) {
@@ -266,9 +271,13 @@ tx::transactions_cleanup::get_active_clients(const std::string& bucket_name, con
           // Write our client record, return details.
           try {
               auto id = config_.atr_id_from_bucket_and_key(bucket_name, CLIENT_RECORD_DOC_ID);
-              couchbase::operations::lookup_in_request req{ id };
-              req.specs.add_spec(protocol::subdoc_opcode::get, true, FIELD_RECORDS);
-              req.specs.add_spec(protocol::subdoc_opcode::get, true, "$vbucket");
+              core::operations::lookup_in_request req{ id };
+              req.specs =
+                lookup_in_specs{
+                    lookup_in_specs::get(FIELD_RECORDS).xattr(),
+                    lookup_in_specs::get("$vbucket").xattr(),
+                }
+                  .specs();
               wrap_request(req, config_);
               auto barrier = std::make_shared<std::promise<result>>();
               auto f = barrier->get_future();
@@ -276,7 +285,7 @@ tx::transactions_cleanup::get_active_clients(const std::string& bucket_name, con
               if (ec) {
                   throw client_error(*ec, "client_record_before_get hook raised error");
               }
-              cluster_.execute(req, [barrier](couchbase::operations::lookup_in_response resp) {
+              cluster_.execute(req, [barrier](core::operations::lookup_in_response resp) {
                   barrier->set_value(result::create_from_subdoc_response(resp));
               });
               auto res = wrap_operation_future(f);
@@ -337,30 +346,25 @@ tx::transactions_cleanup::get_active_clients(const std::string& bucket_name, con
               }
 
               // update client record, maybe cleanup some as well...
-              couchbase::operations::mutate_in_request mutate_req{ id };
-              mutate_req.specs.add_spec(protocol::subdoc_opcode::dict_upsert,
-                                        true,
-                                        true,
-                                        true,
-                                        FIELD_CLIENTS + "." + uuid + "." + FIELD_HEARTBEAT,
-                                        mutate_in_macro::CAS);
-              mutate_req.specs.add_spec(protocol::subdoc_opcode::dict_upsert,
-                                        true,
-                                        true,
-                                        false,
-                                        FIELD_CLIENTS + "." + uuid + "." + FIELD_EXPIRES,
-                                        jsonify(config_.cleanup_window().count() / 2 + SAFETY_MARGIN_EXPIRY_MS));
-              mutate_req.specs.add_spec(protocol::subdoc_opcode::dict_upsert,
-                                        true,
-                                        true,
-                                        false,
-                                        FIELD_CLIENTS + "." + uuid + "." + FIELD_NUM_ATRS,
-                                        jsonify(atr_ids::all().size()));
+              core::operations::mutate_in_request mutate_req{ id };
+              auto mut_specs = couchbase::mutate_in_specs{
+                  couchbase::mutate_in_specs::upsert(FIELD_CLIENTS + "." + uuid + "." + FIELD_HEARTBEAT, subdoc::mutate_in_macro::cas)
+                    .xattr()
+                    .create_path(),
+                  couchbase::mutate_in_specs::upsert(FIELD_CLIENTS + "." + uuid + "." + FIELD_EXPIRES,
+                                                     config_.cleanup_window().count() / 2 + SAFETY_MARGIN_EXPIRY_MS)
+                    .xattr()
+                    .create_path(),
+                  couchbase::mutate_in_specs::upsert(FIELD_CLIENTS + "." + uuid + "." + FIELD_NUM_ATRS, atr_ids::all().size())
+                    .xattr()
+                    .create_path(),
+              };
               for (size_t idx = 0; idx < std::min(details.expired_client_ids.size(), static_cast<size_t>(12)); idx++) {
                   lost_attempts_cleanup_log->trace("adding {} to list of clients to be removed when updating this client",
                                                    details.expired_client_ids[idx]);
-                  mutate_req.specs.add_spec(protocol::subdoc_opcode::remove, true, FIELD_CLIENTS + "." + details.expired_client_ids[idx]);
+                  mut_specs.push_back(couchbase::mutate_in_specs::remove(FIELD_CLIENTS + "." + details.expired_client_ids[idx]).xattr());
               }
+              mutate_req.specs = mut_specs.specs();
               ec = config_.cleanup_hooks().client_record_before_update(bucket_name);
               if (ec) {
                   throw client_error(*ec, "client_record_before_update hook raised error");
@@ -369,7 +373,7 @@ tx::transactions_cleanup::get_active_clients(const std::string& bucket_name, con
               auto mutate_barrier = std::make_shared<std::promise<result>>();
               auto mutate_f = mutate_barrier->get_future();
               lost_attempts_cleanup_log->trace("updating record");
-              cluster_.execute(mutate_req, [mutate_barrier](couchbase::operations::mutate_in_response resp) {
+              cluster_.execute(mutate_req, [mutate_barrier](core::operations::mutate_in_response resp) {
                   mutate_barrier->set_value(result::create_from_subdoc_response(resp));
               });
               res = wrap_operation_future(mutate_f);
@@ -409,12 +413,16 @@ tx::transactions_cleanup::remove_client_record_from_all_buckets(const std::strin
                           throw client_error(*ec, "client_record_before_remove_client hook raised error");
                       }
                       auto id = config_.atr_id_from_bucket_and_key(bucket_name, CLIENT_RECORD_DOC_ID);
-                      couchbase::operations::mutate_in_request req{ id };
-                      req.specs.add_spec(protocol::subdoc_opcode::remove, true, FIELD_CLIENTS + "." + uuid);
+                      core::operations::mutate_in_request req{ id };
+                      req.specs =
+                        couchbase::mutate_in_specs{
+                            couchbase::mutate_in_specs::remove(FIELD_CLIENTS + "." + uuid).xattr(),
+                        }
+                          .specs();
                       wrap_durable_request(req, config_);
                       auto barrier = std::make_shared<std::promise<result>>();
                       auto f = barrier->get_future();
-                      cluster_.execute(req, [barrier](couchbase::operations::mutate_in_response resp) {
+                      cluster_.execute(req, [barrier](core::operations::mutate_in_response resp) {
                           barrier->set_value(result::create_from_subdoc_response(resp));
                       });
                       wrap_operation_future(f);
@@ -478,7 +486,7 @@ tx::transactions_cleanup::lost_attempts_loop()
 }
 
 const tx::atr_cleanup_stats
-tx::transactions_cleanup::force_cleanup_atr(const couchbase::document_id& atr_id, std::vector<transactions_cleanup_attempt>& results)
+tx::transactions_cleanup::force_cleanup_atr(const core::document_id& atr_id, std::vector<transactions_cleanup_attempt>& results)
 {
     lost_attempts_cleanup_log->trace("{} starting force_cleanup_atr: atr_id {}", static_cast<void*>(this), atr_id);
     return handle_atr_cleanup(atr_id, &results);

package/deps/couchbase-transactions-cxx/src/transactions/uid_generator.cxx

@@ -14,12 +14,14 @@
  *   limitations under the License.
  */
 
-#include <couchbase/platform/uuid.h>
+#include <core/platform/uuid.h>
 
 #include "uid_generator.hxx"
 
+// TODO: Remove this, and just use client directly
+
 std::string
 couchbase::transactions::uid_generator::next()
 {
-    return couchbase::uuid::to_string(couchbase::uuid::random());
+    return core::uuid::to_string(core::uuid::random());
 }

package/deps/couchbase-transactions-cxx/tests/transactions/logging_t.cpp

@@ -0,0 +1,126 @@
+/*
+ *     Copyright 2022 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.
+ */
+
+#include "helpers.hxx"
+#include "transactions_env.h"
+#include <couchbase/transactions/internal/logging.hxx>
+#include <filesystem>
+#include <fstream>
+#include <gtest/gtest.h>
+#include <iostream>
+#include <iterator>
+#include <spdlog/fwd.h>
+#include <spdlog/sinks/base_sink.h>
+
+using namespace couchbase::transactions;
+
+auto doc_content = nlohmann::json::parse("{\"some\": \"thing\"}");
+
+class TrivialFileSink : public spdlog::sinks::base_sink<std::mutex>
+{
+  protected:
+    void sink_it_(const spdlog::details::log_msg& msg) override
+    {
+        spdlog::memory_buf_t formatted;
+        base_sink<std::mutex>::formatter_->format(msg, formatted);
+        std::cerr << formatted.data();
+    }
+    void flush_() override
+    {
+    }
+
+  private:
+};
+
+TEST(LoggingTests, CanLogToStdoutByDefault)
+{
+    couchbase::core::logger::create_blackhole_logger();
+    std::string log_message = "I am a log";
+    couchbase::transactions::set_transactions_log_level(couchbase::core::logger::level::debug);
+    testing::internal::CaptureStdout();
+    txn_log->debug(log_message);
+    txn_log->flush();
+    auto out = testing::internal::GetCapturedStdout();
+    ASSERT_FALSE(out.empty());
+    ASSERT_NE(std::string::npos, out.find(log_message));
+    couchbase::core::logger::create_console_logger();
+}
+
+TEST(LoggingTests, LogLevelsWork)
+{
+    couchbase::core::logger::create_blackhole_logger();
+    std::string log_message = "I am a log";
+    couchbase::transactions::set_transactions_log_level(couchbase::core::logger::level::info);
+    testing::internal::CaptureStdout();
+    txn_log->debug(log_message);
+    txn_log->flush();
+    auto out = testing::internal::GetCapturedStdout();
+    ASSERT_TRUE(out.empty());
+    couchbase::core::logger::create_console_logger();
+}
+
+TEST(LoggingTests, CanUseCustomSink)
+{
+    couchbase::core::logger::create_blackhole_logger();
+    std::string log_message = "I am a log";
+    auto sink = std::make_shared<TrivialFileSink>();
+    couchbase::transactions::create_loggers(couchbase::core::logger::level::debug, sink);
+    testing::internal::CaptureStdout();
+    testing::internal::CaptureStderr();
+    txn_log->debug(log_message);
+    txn_log->flush();
+    auto out = testing::internal::GetCapturedStdout();
+    ASSERT_TRUE(out.empty()) << "out = " << out;
+    auto err = testing::internal::GetCapturedStderr();
+    ASSERT_FALSE(err.empty());
+    ASSERT_NE(std::string::npos, err.find(log_message)) << "err = " << err;
+    couchbase::core::logger::create_console_logger();
+}
+
+TEST(LoggingTests, CustomSinkRespectsLogLevels)
+{
+    couchbase::core::logger::create_blackhole_logger();
+    std::string log_message = "I am a log";
+    auto sink = std::make_shared<TrivialFileSink>();
+    couchbase::transactions::create_loggers(couchbase::core::logger::level::info, sink);
+    testing::internal::CaptureStdout();
+    testing::internal::CaptureStderr();
+    txn_log->debug(log_message);
+    txn_log->flush();
+    auto out = testing::internal::GetCapturedStdout();
+    ASSERT_TRUE(out.empty()) << "out = " << out;
+    auto err = testing::internal::GetCapturedStderr();
+    ASSERT_TRUE(err.empty()) << "err = " << err;
+    couchbase::core::logger::create_console_logger();
+}
+
+TEST(LoggingTests, CustomSinkRespectsLogLevelChanges)
+{
+    couchbase::core::logger::create_blackhole_logger();
+    std::string log_message = "I am a log";
+    auto sink = std::make_shared<TrivialFileSink>();
+    couchbase::transactions::create_loggers(couchbase::core::logger::level::debug, sink);
+    couchbase::transactions::set_transactions_log_level(couchbase::core::logger::level::info);
+    testing::internal::CaptureStdout();
+    testing::internal::CaptureStderr();
+    txn_log->debug(log_message);
+    txn_log->flush();
+    auto out = testing::internal::GetCapturedStdout();
+    ASSERT_TRUE(out.empty()) << "out = " << out;
+    auto err = testing::internal::GetCapturedStderr();
+    ASSERT_TRUE(err.empty()) << "err = " << err;
+    couchbase::core::logger::create_console_logger();
+}