couchbase 4.2.0 → 4.2.2

package/deps/couchbase-cxx-client/test/test_unit_connection_string.cxx

@@ -362,6 +362,10 @@ TEST_CASE("unit: connection string", "[unit]")
                                    { "kv_timeout", "4s2ms" },
                                  });
             CHECK(spec.options.key_value_timeout == std::chrono::milliseconds(4002));
+
+            spec = couchbase::core::utils::parse_connection_string(
+              "couchbase://127.0.0.1?user_agent_extra=couchnode%2F4.1.1%20(node%2F12.11.1%3B%20v8%2F7.7.299.11-node.12%3B%20ssl%2F1.1.1c)");
+            CHECK(spec.options.user_agent_extra == "couchnode/4.1.1 (node/12.11.1; v8/7.7.299.11-node.12; ssl/1.1.1c)");
         }
     }
 

package/deps/couchbase-cxx-client/test/test_unit_transaction_logging.cxx

@@ -14,30 +14,26 @@
  *   limitations under the License.
  */
 
+#include "test/utils/wait_until.hxx"
 #include "test_helper.hxx"
-#include "utils/transactions_env.h"
+#include <core/logger/configuration.hxx>
+#include <core/logger/logger.hxx>
+#include <core/transactions/internal/logging.hxx>
 
-#include "core/transactions/internal/logging.hxx"
-
-#include <spdlog/fwd.h>
 #include <spdlog/sinks/base_sink.h>
 
-#include <filesystem>
-#include <fstream>
 #include <iostream>
 #include <iterator>
 
 using namespace couchbase::core::transactions;
 
-static const tao::json::value doc_content{
-    { "some", "thing" },
-};
-
 class TrivialFileSink : public spdlog::sinks::base_sink<std::mutex>
 {
   public:
-    std::string output() const
+    std::string output()
     {
+        // prevent data race if sink_it_ is called
+        std::lock_guard<std::mutex> lock(mut_);
         return out_.str();
     }
 
@@ -46,6 +42,8 @@ class TrivialFileSink : public spdlog::sinks::base_sink<std::mutex>
     {
         spdlog::memory_buf_t formatted;
         base_sink<std::mutex>::formatter_->format(msg, formatted);
+        // prevent data race when calling output()
+        std::lock_guard<std::mutex> lock(mut_);
         out_ << formatted.data();
     }
     void flush_() override
@@ -54,40 +52,79 @@ class TrivialFileSink : public spdlog::sinks::base_sink<std::mutex>
 
   private:
     std::stringstream out_;
+    // needed since we examine the internal state of this object
+    std::mutex mut_;
 };
 
+bool
+sink_has_output(std::shared_ptr<TrivialFileSink> sink)
+{
+    return test::utils::wait_until([&]() { return !sink->output().empty(); }, std::chrono::seconds(2), std::chrono::milliseconds(100));
+}
+
+bool
+sink_is_empty(std::shared_ptr<TrivialFileSink> sink)
+{
+    // now, we need to be sure it is empty, and stays that way for some period of time,
+    // since async loggers don't flush immediately.   The logger is set to flush every
+    // second, so waiting 2 or 3 seems reasonable
+    if (sink->output().empty()) {
+        std::this_thread::sleep_for(std::chrono::seconds(2));
+        return sink->output().empty();
+    }
+    return false;
+}
+
+bool
+sink_output_contains(std::shared_ptr<TrivialFileSink> sink, const std::string& msg)
+{
+    return std::string::npos != sink->output().find(msg);
+}
+
+void
+create_logger(std::shared_ptr<TrivialFileSink> sink, couchbase::core::logger::level level)
+{
+    couchbase::core::logger::configuration conf{};
+    conf.log_level = level;
+    conf.sink = sink;
+    conf.console = false;
+    couchbase::core::logger::create_file_logger(conf);
+}
+
 TEST_CASE("transactions: can use custom sink", "[unit]")
 {
     std::string log_message = "I am a log";
     auto sink = std::make_shared<TrivialFileSink>();
-    create_loggers(couchbase::core::logger::level::debug, sink);
-    txn_log->debug(log_message);
-    txn_log->flush();
-    REQUIRE_FALSE(sink->output().empty());
-    REQUIRE(std::string::npos != sink->output().find(log_message));
+    create_logger(sink, couchbase::core::logger::level::trace);
+    CB_TXN_LOG_DEBUG(log_message);
+    couchbase::core::logger::flush();
+    // ASYNC logger, so flush returns immediately.   Gotta wait...
+    REQUIRE(sink_has_output(sink));
+    REQUIRE(sink_output_contains(sink, log_message));
 }
 
 TEST_CASE("transactions: custom sink respects log levels", "[unit]")
 {
-    couchbase::core::logger::create_blackhole_logger();
     std::string log_message = "I am a log";
+    std::string log_message2 = "I am also a log";
     auto sink = std::make_shared<TrivialFileSink>();
-    create_loggers(couchbase::core::logger::level::info, sink);
-    txn_log->debug(log_message);
-    txn_log->flush();
-    REQUIRE(sink->output().empty());
-    couchbase::core::logger::create_console_logger();
+    create_logger(sink, couchbase::core::logger::level::info);
+    CB_TXN_LOG_DEBUG(log_message);
+    couchbase::core::logger::flush();
+    REQUIRE(sink_is_empty(sink));
+    CB_TXN_LOG_INFO(log_message2);
+    couchbase::core::logger::flush();
+    REQUIRE(sink_has_output(sink));
+    REQUIRE(sink_output_contains(sink, log_message2));
 }
 
 TEST_CASE("transactions: custom sink respects log level changes", "[unit]")
 {
-    couchbase::core::logger::create_blackhole_logger();
     std::string log_message = "I am a log";
     auto sink = std::make_shared<TrivialFileSink>();
-    create_loggers(couchbase::core::logger::level::debug, sink);
-    set_transactions_log_level(couchbase::core::logger::level::info);
-    txn_log->debug(log_message);
-    txn_log->flush();
-    REQUIRE(sink->output().empty());
-    couchbase::core::logger::create_console_logger();
+    create_logger(sink, couchbase::core::logger::level::trace);
+    couchbase::core::logger::set_log_levels(couchbase::core::logger::level::info);
+    CB_TXN_LOG_DEBUG(log_message);
+    couchbase::core::logger::flush();
+    REQUIRE(sink_is_empty(sink));
 }

package/deps/couchbase-cxx-client/test/test_unit_transaction_utils.cxx

@@ -15,12 +15,10 @@
  */
 
 #include "test_helper.hxx"
-#include "utils/transactions_env.h"
 
 #include "core/transactions/internal/exceptions_internal.hxx"
 #include "core/transactions/internal/utils.hxx"
 
-#include <future>
 #include <iostream>
 #include <limits>
 #include <thread>

package/deps/couchbase-cxx-client/test/test_unit_utils.cxx

@@ -18,6 +18,7 @@
 #include "test_helper.hxx"
 
 #include "core/meta/version.hxx"
+#include "core/platform/base64.h"
 #include "core/utils/join_strings.hxx"
 #include "core/utils/json.hxx"
 #include "core/utils/movable_function.hxx"
@@ -84,15 +85,18 @@ TEST_CASE("unit: join strings (fmt version)", "[unit]")
 
 TEST_CASE("unit: user_agent string", "[unit]")
 {
-    std::string core_version = fmt::format("cxx/{}.{}.{}/{}",
+    std::string os_version = fmt::format(";{}/{}", COUCHBASE_CXX_CLIENT_SYSTEM_NAME, COUCHBASE_CXX_CLIENT_SYSTEM_PROCESSOR);
+    std::string core_version = fmt::format("cxx/{}.{}.{}/{};{}/{}",
                                            COUCHBASE_CXX_CLIENT_VERSION_MAJOR,
                                            COUCHBASE_CXX_CLIENT_VERSION_MINOR,
                                            COUCHBASE_CXX_CLIENT_VERSION_PATCH,
-                                           COUCHBASE_CXX_CLIENT_GIT_REVISION_SHORT);
+                                           COUCHBASE_CXX_CLIENT_GIT_REVISION_SHORT,
+                                           COUCHBASE_CXX_CLIENT_SYSTEM_NAME,
+                                           COUCHBASE_CXX_CLIENT_SYSTEM_PROCESSOR);
 
     auto simple_user_agent = couchbase::core::meta::user_agent_for_mcbp("0xDEADBEEF", "0xCAFEBEBE");
     REQUIRE(simple_user_agent == fmt::format(R"({{"a":"{}","i":"0xDEADBEEF/0xCAFEBEBE"}})", core_version));
-    REQUIRE(simple_user_agent.size() == 53);
+    REQUIRE(simple_user_agent.size() == 66);
 
     REQUIRE(couchbase::core::meta::user_agent_for_mcbp("0xDEADBEEF", "0xCAFEBEBE", "couchnode/1.2.3; openssl/1.1.1l") ==
             fmt::format(R"({{"a":"{};couchnode/1.2.3; openssl/1.1.1l","i":"0xDEADBEEF/0xCAFEBEBE"}})", core_version));
@@ -112,15 +116,17 @@ TEST_CASE("unit: user_agent string", "[unit]")
 
     auto trimmed_user_agent = couchbase::core::meta::user_agent_for_mcbp("0xDEADBEEF", "0xCAFEBEBE", long_extra, 250);
     REQUIRE(trimmed_user_agent.size() == 250);
-    REQUIRE(250 - simple_user_agent.size() == 197);
-    REQUIRE(trimmed_user_agent == fmt::format(R"({{"a":"{};{}","i":"0xDEADBEEF/0xCAFEBEBE"}})", core_version, long_extra.substr(0, 196)));
+    REQUIRE(250 - simple_user_agent.size() == 197 - os_version.size());
+    REQUIRE(trimmed_user_agent ==
+            fmt::format(R"({{"a":"{};{}","i":"0xDEADBEEF/0xCAFEBEBE"}})", core_version, long_extra.substr(0, 196 - os_version.size())));
 
-    auto long_extra_with_non_printable_characters = long_extra.substr(0, 193) + "\n\n";
+    auto long_extra_with_non_printable_characters = long_extra.substr(0, 193 - os_version.size()) + "\n\n";
     trimmed_user_agent =
       couchbase::core::meta::user_agent_for_mcbp("0xDEADBEEF", "0xCAFEBEBE", long_extra_with_non_printable_characters, 250);
     REQUIRE(trimmed_user_agent.size() == 249);
-    REQUIRE(trimmed_user_agent ==
-            fmt::format(R"({{"a":"{};{}","i":"0xDEADBEEF/0xCAFEBEBE"}})", core_version, long_extra.substr(0, 193) + "\\n"));
+    REQUIRE(trimmed_user_agent == fmt::format(R"({{"a":"{};{}","i":"0xDEADBEEF/0xCAFEBEBE"}})",
+                                              core_version,
+                                              long_extra.substr(0, 193 - os_version.size()) + "\\n"));
 
     auto long_and_weird_extra = "hello" + std::string(300, '\n');
     trimmed_user_agent = couchbase::core::meta::user_agent_for_mcbp("0xDEADBEEF", "0xCAFEBEBE", long_and_weird_extra, 250);
@@ -146,3 +152,113 @@ TEST_CASE("unit: utils::movable_function should be false after moving value out"
     REQUIRE_FALSE(dst_handler(43));
     REQUIRE_FALSE(src_handler);
 }
+
+TEST_CASE("unit: base64", "[unit]")
+{
+    REQUIRE(couchbase::core::base64::encode(std::vector{ std::byte{ 255 } }, false) == "/w==");
+    REQUIRE(couchbase::core::base64::encode(std::vector{ std::byte{ 255 } }, true) == "/w==\n");
+
+    std::array binary{
+        std::byte{ 0x00 }, std::byte{ 0x01 }, std::byte{ 0x02 }, std::byte{ 0x03 }, std::byte{ 0x04 }, std::byte{ 0x05 }, std::byte{ 0x06 },
+        std::byte{ 0x07 }, std::byte{ 0x08 }, std::byte{ 0x09 }, std::byte{ 0x0a }, std::byte{ 0x0b }, std::byte{ 0x0c }, std::byte{ 0x0d },
+        std::byte{ 0x0e }, std::byte{ 0x0f }, std::byte{ 0x10 }, std::byte{ 0x11 }, std::byte{ 0x12 }, std::byte{ 0x13 }, std::byte{ 0x14 },
+        std::byte{ 0x15 }, std::byte{ 0x16 }, std::byte{ 0x17 }, std::byte{ 0x18 }, std::byte{ 0x19 }, std::byte{ 0x1a }, std::byte{ 0x1b },
+        std::byte{ 0x1c }, std::byte{ 0x1d }, std::byte{ 0x1e }, std::byte{ 0x1f }, std::byte{ 0x20 }, std::byte{ 0x21 }, std::byte{ 0x22 },
+        std::byte{ 0x23 }, std::byte{ 0x24 }, std::byte{ 0x25 }, std::byte{ 0x26 }, std::byte{ 0x27 }, std::byte{ 0x28 }, std::byte{ 0x29 },
+        std::byte{ 0x2a }, std::byte{ 0x2b }, std::byte{ 0x2c }, std::byte{ 0x2d }, std::byte{ 0x2e }, std::byte{ 0x2f }, std::byte{ 0x30 },
+        std::byte{ 0x31 }, std::byte{ 0x32 }, std::byte{ 0x33 }, std::byte{ 0x34 }, std::byte{ 0x35 }, std::byte{ 0x36 }, std::byte{ 0x37 },
+        std::byte{ 0x38 }, std::byte{ 0x39 }, std::byte{ 0x3a }, std::byte{ 0x3b }, std::byte{ 0x3c }, std::byte{ 0x3d }, std::byte{ 0x3e },
+        std::byte{ 0x3f }, std::byte{ 0x40 }, std::byte{ 0x41 }, std::byte{ 0x42 }, std::byte{ 0x43 }, std::byte{ 0x44 }, std::byte{ 0x45 },
+        std::byte{ 0x46 }, std::byte{ 0x47 }, std::byte{ 0x48 }, std::byte{ 0x49 }, std::byte{ 0x4a }, std::byte{ 0x4b }, std::byte{ 0x4c },
+        std::byte{ 0x4d }, std::byte{ 0x4e }, std::byte{ 0x4f }, std::byte{ 0x50 }, std::byte{ 0x51 }, std::byte{ 0x52 }, std::byte{ 0x53 },
+        std::byte{ 0x54 }, std::byte{ 0x55 }, std::byte{ 0x56 }, std::byte{ 0x57 }, std::byte{ 0x58 }, std::byte{ 0x59 }, std::byte{ 0x5a },
+        std::byte{ 0x5b }, std::byte{ 0x5c }, std::byte{ 0x5d }, std::byte{ 0x5e }, std::byte{ 0x5f }, std::byte{ 0x60 }, std::byte{ 0x61 },
+        std::byte{ 0x62 }, std::byte{ 0x63 }, std::byte{ 0x64 }, std::byte{ 0x65 }, std::byte{ 0x66 }, std::byte{ 0x67 }, std::byte{ 0x68 },
+        std::byte{ 0x69 }, std::byte{ 0x6a }, std::byte{ 0x6b }, std::byte{ 0x6c }, std::byte{ 0x6d }, std::byte{ 0x6e }, std::byte{ 0x6f },
+        std::byte{ 0x70 }, std::byte{ 0x71 }, std::byte{ 0x72 }, std::byte{ 0x73 }, std::byte{ 0x74 }, std::byte{ 0x75 }, std::byte{ 0x76 },
+        std::byte{ 0x77 }, std::byte{ 0x78 }, std::byte{ 0x79 }, std::byte{ 0x7a }, std::byte{ 0x7b }, std::byte{ 0x7c }, std::byte{ 0x7d },
+        std::byte{ 0x7e }, std::byte{ 0x7f }, std::byte{ 0x80 }, std::byte{ 0x81 }, std::byte{ 0x82 }, std::byte{ 0x83 }, std::byte{ 0x84 },
+        std::byte{ 0x85 }, std::byte{ 0x86 }, std::byte{ 0x87 }, std::byte{ 0x88 }, std::byte{ 0x89 }, std::byte{ 0x8a }, std::byte{ 0x8b },
+        std::byte{ 0x8c }, std::byte{ 0x8d }, std::byte{ 0x8e }, std::byte{ 0x8f }, std::byte{ 0x90 }, std::byte{ 0x91 }, std::byte{ 0x92 },
+        std::byte{ 0x93 }, std::byte{ 0x94 }, std::byte{ 0x95 }, std::byte{ 0x96 }, std::byte{ 0x97 }, std::byte{ 0x98 }, std::byte{ 0x99 },
+        std::byte{ 0x9a }, std::byte{ 0x9b }, std::byte{ 0x9c }, std::byte{ 0x9d }, std::byte{ 0x9e }, std::byte{ 0x9f }, std::byte{ 0xa0 },
+        std::byte{ 0xa1 }, std::byte{ 0xa2 }, std::byte{ 0xa3 }, std::byte{ 0xa4 }, std::byte{ 0xa5 }, std::byte{ 0xa6 }, std::byte{ 0xa7 },
+        std::byte{ 0xa8 }, std::byte{ 0xa9 }, std::byte{ 0xaa }, std::byte{ 0xab }, std::byte{ 0xac }, std::byte{ 0xad }, std::byte{ 0xae },
+        std::byte{ 0xaf }, std::byte{ 0xb0 }, std::byte{ 0xb1 }, std::byte{ 0xb2 }, std::byte{ 0xb3 }, std::byte{ 0xb4 }, std::byte{ 0xb5 },
+        std::byte{ 0xb6 }, std::byte{ 0xb7 }, std::byte{ 0xb8 }, std::byte{ 0xb9 }, std::byte{ 0xba }, std::byte{ 0xbb }, std::byte{ 0xbc },
+        std::byte{ 0xbd }, std::byte{ 0xbe }, std::byte{ 0xbf }, std::byte{ 0xc0 }, std::byte{ 0xc1 }, std::byte{ 0xc2 }, std::byte{ 0xc3 },
+        std::byte{ 0xc4 }, std::byte{ 0xc5 }, std::byte{ 0xc6 }, std::byte{ 0xc7 }, std::byte{ 0xc8 }, std::byte{ 0xc9 }, std::byte{ 0xca },
+        std::byte{ 0xcb }, std::byte{ 0xcc }, std::byte{ 0xcd }, std::byte{ 0xce }, std::byte{ 0xcf }, std::byte{ 0xd0 }, std::byte{ 0xd1 },
+        std::byte{ 0xd2 }, std::byte{ 0xd3 }, std::byte{ 0xd4 }, std::byte{ 0xd5 }, std::byte{ 0xd6 }, std::byte{ 0xd7 }, std::byte{ 0xd8 },
+        std::byte{ 0xd9 }, std::byte{ 0xda }, std::byte{ 0xdb }, std::byte{ 0xdc }, std::byte{ 0xdd }, std::byte{ 0xde }, std::byte{ 0xdf },
+        std::byte{ 0xe0 }, std::byte{ 0xe1 }, std::byte{ 0xe2 }, std::byte{ 0xe3 }, std::byte{ 0xe4 }, std::byte{ 0xe5 }, std::byte{ 0xe6 },
+        std::byte{ 0xe7 }, std::byte{ 0xe8 }, std::byte{ 0xe9 }, std::byte{ 0xea }, std::byte{ 0xeb }, std::byte{ 0xec }, std::byte{ 0xed },
+        std::byte{ 0xee }, std::byte{ 0xef }, std::byte{ 0xf0 }, std::byte{ 0xf1 }, std::byte{ 0xf2 }, std::byte{ 0xf3 }, std::byte{ 0xf4 },
+        std::byte{ 0xf5 }, std::byte{ 0xf6 }, std::byte{ 0xf7 }, std::byte{ 0xf8 }, std::byte{ 0xf9 }, std::byte{ 0xfa }, std::byte{ 0xfb },
+        std::byte{ 0xfc }, std::byte{ 0xfd }, std::byte{ 0xfe }, std::byte{ 0xff }
+    };
+
+    std::string base64{ "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+"
+                        "P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+"
+                        "AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/"
+                        "wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==" };
+
+    std::string base64_pretty{ "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4v\nMDEyMzQ1Njc4OTo7PD0+"
+                               "P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5f\nYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+"
+                               "AgYKDhIWGh4iJiouMjY6P\nkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/"
+                               "\nwMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v\n8PHy8/T19vf4+fr7/P3+/w==\n" };
+
+    REQUIRE(couchbase::core::base64::encode(binary, false) == base64);
+    REQUIRE(couchbase::core::base64::encode(binary, true) == base64_pretty);
+}
+
+namespace couchbase::core::meta
+{
+std::string
+parse_git_describe_output(const std::string& git_describe_output);
+}
+
+TEST_CASE("unit: semantic version string", "[unit]")
+{
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("1.0.0-beta.4-16-gfbc9922") == "1.0.0-beta.4+16.fbc9922");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("1.0.0-16-gfbc9922") == "1.0.0+16.fbc9922");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("") == "");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("unknown") == "");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("invalid") == "");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("1.0.0.0.0") == "");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("1.0.0-beta.4-0-gfbc9922") == "1.0.0-beta.4");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("1.0.0-beta.4") == "1.0.0-beta.4");
+}
+
+#if 0
+// This test is commented out because, it is not necessary to run it with the suite, but it still useful for debugging.
+
+#include "core/platform/uuid.h"
+
+TEST_CASE("unit: uuid collision", "[unit]")
+{
+    std::array<std::set<std::string>, 10> uuids{};
+    std::vector<std::thread> threads{};
+    threads.reserve(10);
+
+    for (std::size_t t = 0; t < 10; ++t) {
+        threads.emplace_back([&uuids, t]() {
+            for (std::size_t i = 0; i < 1'000'000; ++i) {
+                auto uuid = couchbase::core::uuid::to_string(couchbase::core::uuid::random());
+                uuids[t].insert(uuid);
+            }
+        });
+    }
+    for (std::size_t t = 0; t < 10; ++t) {
+        threads[t].join();
+        REQUIRE(uuids[t].size() == 1'000'000);
+    }
+
+    std::set<std::string> all_uuids{};
+    for (std::size_t t = 0; t < 10; ++t) {
+        for (const auto& uuid : uuids[t]) {
+            REQUIRE(all_uuids.insert(uuid).second);
+        }
+    }
+}
+#endif

package/deps/couchbase-cxx-client/test/tools/tool_kv_loader.cxx

@@ -20,12 +20,55 @@
 #include "../utils/uniq_id.hxx"
 
 #include "core/logger/logger.hxx"
+#include "core/utils/json.hxx"
 
+#include <fmt/format.h>
 #include <spdlog/details/os.h>
 
 #include <csignal>
 #include <thread>
 
+const char* default_json_doc = R"({
+  "type": "fake_profile",
+  "random": 91,
+  "random float": 16.439,
+  "bool": false,
+  "date": "1996-10-23",
+  "regEx": "hellooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo to you",
+  "enum": "online",
+  "firstname": "Anthia",
+  "lastname": "Shields",
+  "city": "Recife",
+  "country": "Malawi",
+  "countryCode": "CA",
+  "email uses current data": "Anthia.Shields@gmail.com",
+  "email from expression": "Anthia.Shields@yopmail.com",
+  "array": [
+    "Augustine",
+    "Pearline",
+    "Fredericka",
+    "Dorothy",
+    "Roz"
+  ],
+  "array of objects": [
+    {
+      "index": 0,
+      "index start at 5": 5
+    },
+    {
+      "index": 1,
+      "index start at 5": 6
+    },
+    {
+      "index": 2,
+      "index start at 5": 7
+    }
+  ],
+  "Mildrid": {
+    "age": 33
+  }
+})";
+
 enum class operation {
     get,
     upsert,
@@ -33,13 +76,15 @@ enum class operation {
 
 namespace
 {
-volatile std::sig_atomic_t running{ 1 };
+std::atomic_flag running{ 1 };
+std::size_t operations_limit{ 0 };
+
 } // namespace
 
 void
 sigint_handler(int /* signal */)
 {
-    running = 0;
+    running.test_and_set();
 }
 
 static void
@@ -57,6 +102,28 @@ dump_stats(asio::steady_timer& timer, std::chrono::system_clock::time_point star
     });
 }
 
+static std::string
+random_text(std::size_t length)
+{
+    std::string alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    static thread_local std::mt19937_64 gen{ std::random_device()() };
+    std::uniform_int_distribution<std::size_t> dis(0, alphabet.size() - 1);
+    std::string text(length, '-');
+    for (std::size_t i = 0; i < length; ++i) {
+        text[i] = alphabet[dis(gen)];
+    }
+    return text;
+}
+
+static bool
+parse_boolean(std::string_view value)
+{
+    static std::vector<std::string> truth = {
+        "YES", "Y", "TRUE", "T", "ON", "1", "yes", "y", "true", "t", "on",
+    };
+    return std::any_of(truth.begin(), truth.end(), [&value](auto& t) { return t == value; });
+}
+
 int
 main()
 {
@@ -69,24 +136,52 @@ main()
 
     auto ctx = test::utils::test_context::load_from_environment();
 
-    bool send_queries = false;
+    bool send_queries{ false };
     if (auto val = spdlog::details::os::getenv("TEST_SEND_QUERIES"); !val.empty()) {
-        std::vector<std::string> truth = {
-            "YES", "Y", "TRUE", "T", "ON", "1", "yes", "y", "true", "t", "on",
+        send_queries = parse_boolean(val);
+    }
+
+    if (auto val = spdlog::details::os::getenv("TEST_OPERATIONS_LIMIT"); !val.empty()) {
+        operations_limit = std::stoul(val, nullptr, 10);
+    }
+
+    bool incompressible_body{ true };
+    if (auto val = spdlog::details::os::getenv("TEST_INCOMPRESSIBLE_BODY"); !val.empty()) {
+        incompressible_body = parse_boolean(val);
+    }
+
+    std::vector<std::byte> json_doc{};
+    if (auto val = spdlog::details::os::getenv("TEST_DOCUMENT_SIZE"); !val.empty()) {
+        std::size_t document_size = std::stoul(val, nullptr, 10);
+        tao::json::value doc = {
+            { "size", document_size },
+            { "text", incompressible_body ? random_text(document_size) : std::string(document_size, 'x') },
         };
-        send_queries = std::any_of(truth.begin(), truth.end(), [&val](auto& t) { return t == val; });
+        json_doc = couchbase::core::utils::json::generate_binary(doc);
+    } else {
+        json_doc = couchbase::core::utils::to_binary(default_json_doc);
     }
 
     std::size_t number_of_io_threads = 4;
     if (auto val = spdlog::details::os::getenv("TEST_NUMBER_OF_IO_THREADS"); !val.empty()) {
         number_of_io_threads = std::stoul(val, nullptr, 10);
     }
-    LOG_INFO("send_queries: {}, number_of_threads: {}, username: \"{}\", connection_string: \"{}\", bucket: \"{}\"",
-             send_queries,
-             number_of_io_threads,
-             ctx.username,
-             ctx.connection_string,
-             ctx.bucket);
+    fmt::print("TEST_SEND_QUERIES={}\n"
+               "TEST_NUMBER_OF_IO_THREADS={}\n"
+               "TEST_OPERATIONS_LIMIT={}\n"
+               "TEST_INCOMPRESSIBLE_BODY={}\n"
+               "TEST_DOCUMENT_SIZE={}\n"
+               "TEST_USERNAME=\"{}\"\n"
+               "TEST_CONNECTION_STRING=\"{}\"\n"
+               "TEST_BUCKET=\"{}\"\n",
+               send_queries,
+               number_of_io_threads,
+               operations_limit > 0 ? std::to_string(operations_limit) : "unbounded",
+               incompressible_body,
+               json_doc.size(),
+               ctx.username,
+               ctx.connection_string,
+               ctx.bucket);
 
     auto connstr = couchbase::core::utils::parse_connection_string(ctx.connection_string);
     couchbase::core::cluster_credentials auth{};
@@ -112,7 +207,7 @@ main()
     std::vector<std::thread> io_pool{};
     io_pool.reserve(number_of_io_threads);
     for (std::size_t i = 0; i < number_of_io_threads; ++i) {
-        io_pool.emplace_back(std::thread([&io]() { io.run(); }));
+        io_pool.emplace_back([&io]() { io.run(); });
     }
 
     test::utils::open_cluster(cluster, origin);
@@ -121,11 +216,21 @@ main()
     std::vector<std::string> known_keys{};
 
     double chance_of_get = 0.6;
+    if (auto val = spdlog::details::os::getenv("TEST_CHANCE_OF_GET"); !val.empty()) {
+        chance_of_get = std::stod(val, nullptr);
+    }
+
     double hit_chance_for_upsert = 0.7;
+    if (auto val = spdlog::details::os::getenv("TEST_HIT_CHANCE_FOR_UPSERT"); !val.empty()) {
+        hit_chance_for_upsert = std::stod(val, nullptr);
+    }
+
     double hit_chance_for_get = 1.0;
+    if (auto val = spdlog::details::os::getenv("TEST_HIT_CHANCE_FOR_GET"); !val.empty()) {
+        hit_chance_for_get = std::stod(val, nullptr);
+    }
 
-    std::random_device rd;
-    std::mt19937 gen(rd());
+    static thread_local std::mt19937_64 gen{ std::random_device()() };
     std::uniform_real_distribution<double> dist(0, 1);
 
     std::atomic_uint64_t total{};
@@ -135,58 +240,19 @@ main()
     std::signal(SIGINT, sigint_handler);
     std::signal(SIGTERM, sigint_handler);
 
-    LOG_INFO("start workload, chance_of_get: {}, hit_chance_for_upsert: {}, hit_chance_for_get: {}",
-             chance_of_get,
-             hit_chance_for_upsert,
-             hit_chance_for_get);
-
-    const auto json_doc = couchbase::core::utils::to_binary(R"({
-  "type": "fake_profile",
-  "random": 91,
-  "random float": 16.439,
-  "bool": false,
-  "date": "1996-10-23",
-  "regEx": "hellooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo to you",
-  "enum": "online",
-  "firstname": "Anthia",
-  "lastname": "Shields",
-  "city": "Recife",
-  "country": "Malawi",
-  "countryCode": "CA",
-  "email uses current data": "Anthia.Shields@gmail.com",
-  "email from expression": "Anthia.Shields@yopmail.com",
-  "array": [
-    "Augustine",
-    "Pearline",
-    "Fredericka",
-    "Dorothy",
-    "Roz"
-  ],
-  "array of objects": [
-    {
-      "index": 0,
-      "index start at 5": 5
-    },
-    {
-      "index": 1,
-      "index start at 5": 6
-    },
-    {
-      "index": 2,
-      "index start at 5": 7
-    }
-  ],
-  "Mildrid": {
-    "age": 33
-  }
-})");
+    fmt::print("TEST_CHANCE_OF_GET={}\n"
+               "TEST_HIT_CHANCE_FOR_UPSERT={}\n"
+               "TEST_HIT_CHANCE_FOR_GET={}\n",
+               chance_of_get,
+               hit_chance_for_upsert,
+               hit_chance_for_get);
 
     const auto start_time = std::chrono::system_clock::now();
 
     asio::steady_timer stats_timer(io);
     dump_stats(stats_timer, start_time, total);
-    while (running != 0) {
-        auto opcode = chance_of_get >= dist(gen) ? operation::get : operation::upsert;
+    while (running.test_and_set()) {
+        auto opcode = dist(gen) <= chance_of_get ? operation::get : operation::upsert;
         if (opcode == operation::get && known_keys.empty()) {
             opcode = operation::upsert;
         }
@@ -209,7 +275,7 @@ main()
 
         couchbase::core::document_id id{ ctx.bucket, "_default", "_default", current_key };
         switch (opcode) {
-            case operation::get: {
+            case operation::upsert: {
                 couchbase::core::operations::upsert_request req{ id, json_doc };
                 cluster->execute(req, [&total, &errors_mutex, &errors](const couchbase::core::operations::upsert_response& resp) {
                     ++total;
@@ -217,9 +283,12 @@ main()
                         std::scoped_lock lock(errors_mutex);
                         ++errors[resp.ctx.ec()];
                     }
+                    if (operations_limit > 0 && total >= operations_limit) {
+                        running.clear();
+                    }
                 });
             } break;
-            case operation::upsert: {
+            case operation::get: {
                 couchbase::core::operations::get_request req{ id };
                 cluster->execute(req, [&total, &errors_mutex, &errors](const couchbase::core::operations::get_response&& resp) {
                     ++total;
@@ -227,6 +296,9 @@ main()
                         std::scoped_lock lock(errors_mutex);
                         ++errors[resp.ctx.ec()];
                     }
+                    if (operations_limit > 0 && total >= operations_limit) {
+                        running.clear();
+                    }
                 });
             } break;
         }
@@ -239,13 +311,16 @@ main()
                     std::scoped_lock lock(errors_mutex);
                     ++errors[resp.ctx.ec];
                 }
+                if (operations_limit > 0 && total > operations_limit) {
+                    running.clear();
+                }
             });
         }
     }
     const auto finish_time = std::chrono::system_clock::now();
     stats_timer.cancel();
 
-    fmt::print("total operations: {}\n", total);
+    fmt::print("\n\ntotal operations: {}\n", total);
     fmt::print("total keys used: {}\n", known_keys.size());
     const auto total_time = finish_time - start_time;
     fmt::print("total time: {}s ({}ms)\n",