couchbase 4.2.0 → 4.2.1

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,25 +14,17 @@
  *   limitations under the License.
  */
 
-#include "test_helper.hxx"
-#include "utils/transactions_env.h"
-
 #include "core/transactions/internal/logging.hxx"
+#include "test_helper.hxx"
+#include <core/transactions.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:
@@ -58,6 +50,7 @@ class TrivialFileSink : public spdlog::sinks::base_sink<std::mutex>
 
 TEST_CASE("transactions: can use custom sink", "[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);

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,62 @@ 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);
+}

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::minstd_rand 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::minstd_rand 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",

package/deps/couchbase-cxx-client/test/utils/integration_shortcuts.cxx

@@ -29,7 +29,7 @@ open_cluster(std::shared_ptr<couchbase::core::cluster> cluster, const couchbase:
     cluster->open(origin, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
     auto rc = f.get();
     if (rc) {
-        LOG_CRITICAL(
+        CB_LOG_CRITICAL(
           "unable to connect to the cluster: {}, nodes={}", rc.message(), couchbase::core::utils::join_strings(origin.get_nodes(), ", "));
         throw std::system_error(rc);
     }
@@ -51,7 +51,7 @@ open_bucket(std::shared_ptr<couchbase::core::cluster> cluster, const std::string
     cluster->open_bucket(bucket_name, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
     auto rc = f.get();
     if (rc) {
-        LOG_CRITICAL("unable to open bucket: {}, name={}", rc.message(), bucket_name);
+        CB_LOG_CRITICAL("unable to open bucket: {}, name={}", rc.message(), bucket_name);
         throw std::system_error(rc);
     }
 }
@@ -64,7 +64,7 @@ close_bucket(std::shared_ptr<couchbase::core::cluster> cluster, const std::strin
     cluster->close_bucket(bucket_name, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
     auto rc = f.get();
     if (rc) {
-        LOG_CRITICAL("unable to close bucket: {}, name={}", rc.message(), bucket_name);
+        CB_LOG_CRITICAL("unable to close bucket: {}, name={}", rc.message(), bucket_name);
         throw std::system_error(rc);
     }
 }

package/deps/couchbase-cxx-client/test/utils/integration_test_guard.cxx

@@ -16,15 +16,47 @@
  */
 
 #include "integration_test_guard.hxx"
+
 #include "core/operations/management/freeform.hxx"
 #include "core/utils/json.hxx"
 #include "logger.hxx"
 
 namespace test::utils
 {
+static void
+set_thread_name(const char* name)
+{
+#if defined(__APPLE__)
+    ::pthread_setname_np(name);
+#elif defined(__FreeBSD__)
+    ::pthread_set_name_np(::pthread_self(), name);
+#elif defined(__linux__)
+    ::pthread_setname_np(::pthread_self(), name);
+#elif defined(__NetBSD__)
+    ::pthread_setname_np(::pthread_self(), "%s", name);
+#else
+    (void)name;
+#endif
+}
+
+static auto
+spawn_io_threads(asio::io_context& io, std::size_t number_of_threads) -> std::vector<std::thread>
+{
+    std::vector<std::thread> threads;
+    threads.reserve(number_of_threads);
+    for (std::size_t i = 0; i < number_of_threads; i++) {
+        threads.emplace_back([&io, i]() mutable {
+            set_thread_name(fmt::format("cxx_io_{}", i).c_str());
+            io.run();
+        });
+    }
+    return threads;
+}
+
 integration_test_guard::integration_test_guard()
-  : cluster(couchbase::core::cluster::create(io))
-  , ctx(test_context::load_from_environment())
+  : ctx(test_context::load_from_environment())
+  , io(static_cast<int>(ctx.number_of_io_threads))
+  , cluster(couchbase::core::cluster::create(io))
 {
     init_logger();
     auto connstr = couchbase::core::utils::parse_connection_string(ctx.connection_string);
@@ -36,7 +68,7 @@ integration_test_guard::integration_test_guard()
         auth.username = ctx.username;
         auth.password = ctx.password;
     }
-    io_thread = std::thread([this]() { io.run(); });
+    io_threads = spawn_io_threads(io, ctx.number_of_io_threads);
     origin = couchbase::core::origin(auth, connstr);
     if (ctx.dns_nameserver || ctx.dns_port) {
         origin.options().dns_config = couchbase::core::io::dns::dns_config{
@@ -48,24 +80,27 @@ integration_test_guard::integration_test_guard()
 }
 
 integration_test_guard::integration_test_guard(const couchbase::core::cluster_options& opts)
+  : ctx(test_context::load_from_environment())
+  , io(static_cast<int>(ctx.number_of_io_threads))
+  , cluster(couchbase::core::cluster::create(io))
 {
     init_logger();
-    ctx = test_context::load_from_environment();
     auto auth = ctx.build_auth();
     auto connstr = couchbase::core::utils::parse_connection_string(ctx.connection_string);
     // for now, lets _only_ add a tracer or meter from the incoming options
     connstr.options.meter = opts.meter;
     connstr.options.tracer = opts.tracer;
     couchbase::core::origin orig(auth, connstr);
-    cluster = couchbase::core::cluster::create(io);
-    io_thread = std::thread([this]() { io.run(); });
+    io_threads = spawn_io_threads(io, ctx.number_of_io_threads);
     open_cluster(cluster, orig);
 }
 
 integration_test_guard::~integration_test_guard()
 {
     close_cluster(cluster);
-    io_thread.join();
+    for (auto& thread : io_threads) {
+        thread.join();
+    }
 }
 
 const couchbase::core::operations::management::bucket_describe_response::bucket_info&
@@ -81,7 +116,7 @@ integration_test_guard::load_bucket_info(const std::string& bucket_name, bool re
         resp = execute(cluster, couchbase::core::operations::management::bucket_describe_request{ bucket_name });
     }
     if (resp.ctx.ec) {
-        LOG_CRITICAL("unable to load info for bucket \"{}\": {}", bucket_name, resp.ctx.ec.message());
+        CB_LOG_CRITICAL("unable to load info for bucket \"{}\": {}", bucket_name, resp.ctx.ec.message());
         throw std::system_error(resp.ctx.ec);
     }
 
@@ -102,7 +137,7 @@ integration_test_guard::load_cluster_info(bool refresh)
         resp = execute(cluster, couchbase::core::operations::management::cluster_describe_request{});
     }
     if (resp.ctx.ec) {
-        LOG_CRITICAL("unable to load info for cluster: {}", resp.ctx.ec.message());
+        CB_LOG_CRITICAL("unable to load info for cluster: {}", resp.ctx.ec.message());
         throw std::system_error(resp.ctx.ec);
     }
 
@@ -124,7 +159,7 @@ integration_test_guard::load_pools_info(bool refresh)
     req.path = "/pools";
     auto resp = execute(cluster, req);
     if (resp.ctx.ec || resp.status != 200) {
-        LOG_CRITICAL("unable to load pools info for cluster: {}", resp.ctx.ec.message());
+        CB_LOG_CRITICAL("unable to load pools info for cluster: {}", resp.ctx.ec.message());
         throw std::system_error(resp.ctx.ec);
     }
 

package/deps/couchbase-cxx-client/test/utils/integration_test_guard.hxx

@@ -74,6 +74,16 @@ class integration_test_guard
         return load_bucket_info(ctx.bucket).storage_backend;
     }
 
+    inline bool has_bucket_capability(const std::string& bucket_name, const std::string& capability)
+    {
+        return load_bucket_info(bucket_name).has_capability(capability);
+    }
+
+    inline bool has_bucket_capability(const std::string& capability)
+    {
+        return has_bucket_capability(ctx.bucket, capability);
+    }
+
     const couchbase::core::operations::management::cluster_describe_response::cluster_info& load_cluster_info(bool refresh = false);
 
     pools_response load_pools_info(bool refresh = false);
@@ -103,10 +113,10 @@ class integration_test_guard
 
     server_version cluster_version();
 
-    std::thread io_thread{};
-    asio::io_context io{};
-    std::shared_ptr<couchbase::core::cluster> cluster;
     test_context ctx;
+    asio::io_context io;
+    std::vector<std::thread> io_threads;
+    std::shared_ptr<couchbase::core::cluster> cluster;
     couchbase::core::origin origin;
 
     std::map<std::string, couchbase::core::operations::management::bucket_describe_response::bucket_info, std::less<>> info{};