couchbase 4.2.8 → 4.2.10

package/deps/couchbase-cxx-client/core/transactions/attempt_context_impl.cxx

@@ -44,8 +44,8 @@ static const tao::json::value KV_TXDATA{ { "kv", true } };
 // the config may have nullptr for attempt context hooks, so we use the noop here in that case
 static auto noop_hooks = attempt_context_testing_hooks{};
 
-std::shared_ptr<core::cluster>
-attempt_context_impl::cluster_ref()
+const core::cluster&
+attempt_context_impl::cluster_ref() const
 {
     return overall_.cluster_ref();
 }
@@ -340,8 +340,7 @@ attempt_context_impl::replace_raw(const transaction_get_result& document, const
                             }
                             if (existing_sm != nullptr && existing_sm->type() == staged_mutation_type::INSERT) {
                                 CB_ATTEMPT_CTX_LOG_DEBUG(this, "found existing INSERT of {} while replacing", document);
-                                exp_delay delay(
-                                  std::chrono::milliseconds(5), std::chrono::milliseconds(300), overall_.config().expiration_time);
+                                exp_delay delay(std::chrono::milliseconds(5), std::chrono::milliseconds(300), overall_.config().timeout);
                                 create_staged_insert(document.id(), content, existing_sm->doc().cas().value(), delay, op_id, std::move(cb));
                                 return;
                             }
@@ -393,7 +392,7 @@ attempt_context_impl::create_staged_replace(const transaction_get_result& docume
     }
     CB_ATTEMPT_CTX_LOG_TRACE(
       this, "about to replace doc {} with cas {} in txn {}", document.id(), document.cas().value(), overall_.transaction_id());
-    overall_.cluster_ref()->execute(
+    overall_.cluster_ref().execute(
       req,
       [this, document = std::move(document), content, cb = std::move(cb), error_handler = std::move(error_handler)](
         core::operations::mutate_in_response resp) mutable {
@@ -478,7 +477,7 @@ attempt_context_impl::insert_raw(const core::document_id& id, const std::vector<
                           return create_staged_replace(existing_sm->doc(), content, op_id, std::move(cb));
                       }
                       uint64_t cas = 0;
-                      exp_delay delay(std::chrono::milliseconds(5), std::chrono::milliseconds(300), overall_.config().expiration_time);
+                      exp_delay delay(std::chrono::milliseconds(5), std::chrono::milliseconds(300), overall_.config().timeout);
                       create_staged_insert(id, content, cas, delay, op_id, std::move(cb));
                   });
             } catch (const std::exception& e) {
@@ -645,7 +644,7 @@ attempt_context_impl::remove(const transaction_get_result& document, VoidCallbac
                         auto req = create_staging_request(document.id(), &document, "remove", op_id);
                         req.cas = document.cas();
                         req.access_deleted = document.links().is_deleted();
-                        overall_.cluster_ref()->execute(
+                        overall_.cluster_ref().execute(
                           req,
                           [this, document = std::move(document), cb = std::move(cb), error_handler = std::move(error_handler)](
                             core::operations::mutate_in_response resp) mutable {
@@ -702,23 +701,23 @@ attempt_context_impl::remove_staged_insert(const core::document_id& id, VoidCall
     wrap_durable_request(req, overall_.config());
     req.access_deleted = true;
 
-    overall_.cluster_ref()->execute(req,
-                                    [this, id = std::move(id), cb = std::move(cb), error_handler = std::move(error_handler)](
-                                      core::operations::mutate_in_response resp) mutable {
-                                        auto ec = error_class_from_response(resp);
-                                        if (!ec) {
-
-                                            if (auto err = hooks_.after_remove_staged_insert(this, id.key()); err) {
-                                                error_handler(*err, "after_remove_staged_insert hook returned error", std::move(cb));
-                                                return;
-                                            }
-                                            staged_mutations_->remove_any(id);
-                                            op_completed_with_callback(std::move(cb));
-                                            return;
-                                        }
-                                        CB_ATTEMPT_CTX_LOG_DEBUG(this, "remove_staged_insert got error {}", *ec);
-                                        return error_handler(*ec, resp.ctx.ec().message(), std::move(cb));
-                                    });
+    overall_.cluster_ref().execute(req,
+                                   [this, id = std::move(id), cb = std::move(cb), error_handler = std::move(error_handler)](
+                                     core::operations::mutate_in_response resp) mutable {
+                                       auto ec = error_class_from_response(resp);
+                                       if (!ec) {
+
+                                           if (auto err = hooks_.after_remove_staged_insert(this, id.key()); err) {
+                                               error_handler(*err, "after_remove_staged_insert hook returned error", std::move(cb));
+                                               return;
+                                           }
+                                           staged_mutations_->remove_any(id);
+                                           op_completed_with_callback(std::move(cb));
+                                           return;
+                                       }
+                                       CB_ATTEMPT_CTX_LOG_DEBUG(this, "remove_staged_insert got error {}", *ec);
+                                       return error_handler(*ec, resp.ctx.ec().message(), std::move(cb));
+                                   });
 }
 
 void
@@ -764,8 +763,9 @@ attempt_context_impl::query_begin_work(std::optional<std::string> query_context,
     txdata["state"] = tao::json::empty_object;
     txdata["state"]["timeLeftMs"] = overall_.remaining().count() / 1000000;
     txdata["config"] = tao::json::empty_object;
+    auto [ec, origin] = overall_.cluster_ref().origin();
     txdata["config"]["kvTimeoutMs"] =
-      overall_.config().kv_timeout ? overall_.config().kv_timeout->count() : core::timeout_defaults::key_value_timeout.count();
+      (ec) ? core::timeout_defaults::key_value_durable_timeout.count() : origin.options().key_value_durable_timeout.count();
     txdata["config"]["numAtrs"] = 1024;
     opts.raw("numatrs", jsonify(1024));
     txdata["config"]["durabilityLevel"] = durability_level_to_string(overall_.config().level);
@@ -1026,7 +1026,7 @@ attempt_context_impl::wrap_query(const std::string& statement,
         return cb(std::make_exception_ptr(transaction_operation_failed(*ec, "before_query hook raised error")), {});
     }
     CB_ATTEMPT_CTX_LOG_TRACE(this, "http request: {}", dump_request(req));
-    overall_.cluster_ref()->execute(req, [this, cb = std::move(cb)](core::operations::query_response resp) mutable {
+    overall_.cluster_ref().execute(req, [this, cb = std::move(cb)](core::operations::query_response resp) mutable {
         CB_ATTEMPT_CTX_LOG_TRACE(this, "response: {} status: {}", resp.ctx.http_body, resp.meta.status);
         if (auto ec = hooks_.after_query(this, resp.ctx.statement)) {
             auto err = std::make_exception_ptr(transaction_operation_failed(*ec, "after_query hook raised error"));
@@ -1397,7 +1397,7 @@ attempt_context_impl::atr_commit(bool ambiguity_resolution_mode)
             auto barrier = std::make_shared<std::promise<result>>();
             auto f = barrier->get_future();
             CB_ATTEMPT_CTX_LOG_TRACE(this, "updating atr {}, setting to {}", req.id, attempt_state_name(attempt_state::COMMITTED));
-            overall_.cluster_ref()->execute(
+            overall_.cluster_ref().execute(
               req, [barrier](core::operations::mutate_in_response resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
             auto res = wrap_operation_future(f, false);
             ec = hooks_.after_atr_commit(this);
@@ -1496,10 +1496,9 @@ attempt_context_impl::atr_commit_ambiguity_resolution()
         std::string prefix(ATR_FIELD_ATTEMPTS + "." + id() + ".");
         core::operations::lookup_in_request req{ atr_id_.value() };
         req.specs = lookup_in_specs{ lookup_in_specs::get(prefix + ATR_FIELD_STATUS).xattr() }.specs();
-        wrap_request(req, overall_.config());
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
-        overall_.cluster_ref()->execute(
+        overall_.cluster_ref().execute(
           req, [barrier](core::operations::lookup_in_response resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
         auto res = wrap_operation_future(f);
         auto atr_status_raw = res.values[0].content_as<std::string>();
@@ -1560,7 +1559,7 @@ attempt_context_impl::atr_complete()
         wrap_durable_request(req, overall_.config());
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
-        overall_.cluster_ref()->execute(
+        overall_.cluster_ref().execute(
           req, [barrier](core::operations::mutate_in_response resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
         wrap_operation_future(f);
         ec = hooks_.after_atr_complete(this);
@@ -1660,7 +1659,7 @@ attempt_context_impl::atr_abort()
         wrap_durable_request(req, overall_.config());
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
-        overall_.cluster_ref()->execute(
+        overall_.cluster_ref().execute(
           req, [barrier](core::operations::mutate_in_response resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
         wrap_operation_future(f);
         state(attempt_state::ABORTED);
@@ -1718,7 +1717,7 @@ attempt_context_impl::atr_rollback_complete()
         wrap_durable_request(req, overall_.config());
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
-        overall_.cluster_ref()->execute(
+        overall_.cluster_ref().execute(
           req, [barrier](core::operations::mutate_in_response resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
         wrap_operation_future(f);
         state(attempt_state::ROLLED_BACK);
@@ -1805,7 +1804,7 @@ attempt_context_impl::rollback()
     }
     if (is_done()) {
         std::string msg("Transaction already done, cannot rollback");
-        CB_ATTEMPT_CTX_LOG_ERROR(this, msg);
+        CB_ATTEMPT_CTX_LOG_ERROR(this, "{}", msg);
         // need to raise a FAIL_OTHER which is not retryable or rollback-able
         throw transaction_operation_failed(FAIL_OTHER, msg).no_rollback();
     }
@@ -1935,10 +1934,10 @@ attempt_context_impl::set_atr_pending_locked(const core::document_id& id, std::u
             CB_ATTEMPT_CTX_LOG_DEBUG(this, "updating atr {}", atr_id_.value());
 
             std::chrono::nanoseconds remaining = overall_.remaining();
-            // This bounds the value to [0-expirationTime].  It should always be in this range, this is just to protect
+            // This bounds the value to [0-timeout].  It should always be in this range, this is just to protect
             // against the application clock changing.
-            long remaining_bounded_nanos = std::max(std::min(remaining.count(), overall_.config().expiration_time.count()),
-                                                    static_cast<std::chrono::nanoseconds::rep>(0));
+            long remaining_bounded_nanos =
+              std::max(std::min(remaining.count(), overall_.config().timeout.count()), static_cast<std::chrono::nanoseconds::rep>(0));
             long remaining_bounded_msecs = remaining_bounded_nanos / 1'000'000;
 
             core::operations::mutate_in_request req{ atr_id_.value() };
@@ -1966,7 +1965,7 @@ attempt_context_impl::set_atr_pending_locked(const core::document_id& id, std::u
             req.store_semantics = couchbase::store_semantics::upsert;
 
             wrap_durable_request(req, overall_.config());
-            overall_.cluster_ref()->execute(
+            overall_.cluster_ref().execute(
               req, [this, fn = std::forward<Handler>(fn), error_handler](core::operations::mutate_in_response resp) mutable {
                   auto ec = error_class_from_response(resp);
                   if (!ec) {
@@ -2031,7 +2030,7 @@ attempt_context_impl::do_get(const core::document_id& id, const std::optional<st
         staged_mutation* own_remove = staged_mutations_->find_remove(id);
         if (own_remove) {
             auto msg = fmt::format("found own-write of removed doc {}", id);
-            CB_ATTEMPT_CTX_LOG_DEBUG(this, msg);
+            CB_ATTEMPT_CTX_LOG_DEBUG(this, "{}", msg);
             return cb(FAIL_DOC_NOT_FOUND, msg, std::nullopt);
         }
 
@@ -2176,9 +2175,8 @@ attempt_context_impl::get_doc(
       }
         .specs();
     req.access_deleted = true;
-    wrap_request(req, overall_.config());
     try {
-        overall_.cluster_ref()->execute(req, [this, id, cb = std::move(cb)](core::operations::lookup_in_response resp) {
+        overall_.cluster_ref().execute(req, [this, id, cb = std::move(cb)](core::operations::lookup_in_response resp) {
             auto ec = error_class_from_response(resp);
             if (ec) {
                 CB_ATTEMPT_CTX_LOG_TRACE(this, "get_doc got error {} : {}", resp.ctx.ec().message(), *ec);
@@ -2369,7 +2367,7 @@ attempt_context_impl::create_staged_insert(const core::document_id& id,
     req.cas = couchbase::cas(cas);
     req.store_semantics = cas == 0 ? couchbase::store_semantics::insert : couchbase::store_semantics::replace;
     wrap_durable_request(req, overall_.config());
-    overall_.cluster_ref()->execute(
+    overall_.cluster_ref().execute(
       req,
       [this, id, content, cas, op_id, cb = std::forward<Handler>(cb), delay = std::forward<Delay>(delay)](
         core::operations::mutate_in_response resp) mutable {

package/deps/couchbase-cxx-client/core/transactions/attempt_context_impl.hxx

@@ -331,7 +331,7 @@ class attempt_context_impl
         }
     }
 
-    std::shared_ptr<core::cluster> cluster_ref();
+    const core::cluster& cluster_ref() const;
 
   public:
     explicit attempt_context_impl(transaction_context& transaction_ctx);
@@ -627,7 +627,7 @@ class attempt_context_impl
             CB_LOG_DEBUG("ensure_open_bucket called with empty bucket_name");
             return handler(couchbase::errc::common::bucket_not_found);
         }
-        cluster_ref()->open_bucket(bucket_name, [handler = std::move(handler)](std::error_code ec) { handler(ec); });
+        cluster_ref().open_bucket(bucket_name, [handler = std::move(handler)](std::error_code ec) { handler(ec); });
     }
 };
 

package/deps/couchbase-cxx-client/core/transactions/internal/atr_cleanup_entry.hxx

@@ -17,11 +17,13 @@
 #pragma once
 
 #include "atr_entry.hxx"
+#include "core/document_id_fmt.hxx"
 #include "core/transactions/transaction_get_result.hxx"
 #include "logging.hxx"
 
-#include <chrono>
 #include <fmt/format.h>
+
+#include <chrono>
 #include <memory>
 #include <mutex>
 #include <optional>

package/deps/couchbase-cxx-client/core/transactions/internal/atr_entry.hxx

@@ -19,6 +19,8 @@
 #include "core/transactions/attempt_state.hxx"
 #include "doc_record.hxx"
 
+#include <tao/json/value.hpp>
+
 #include <chrono>
 #include <cstdint>
 #include <optional>

package/deps/couchbase-cxx-client/core/transactions/internal/doc_record.cxx

@@ -0,0 +1,32 @@
+/*
+ *     Copyright 2021-Present 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 "doc_record.hxx"
+
+#include <tao/json/value.hpp>
+
+namespace couchbase::core::transactions
+{
+doc_record
+doc_record::create_from(const tao::json::value& obj)
+{
+    std::string bucket_name = obj.at(ATR_FIELD_PER_DOC_BUCKET).get_string();
+    std::string scope_name = obj.at(ATR_FIELD_PER_DOC_SCOPE).get_string();
+    std::string collection_name = obj.at(ATR_FIELD_PER_DOC_COLLECTION).get_string();
+    std::string id = obj.at(ATR_FIELD_PER_DOC_ID).get_string();
+    return doc_record(bucket_name, scope_name, collection_name, id);
+}
+} // namespace couchbase::core::transactions

package/deps/couchbase-cxx-client/core/transactions/internal/doc_record.hxx

@@ -19,6 +19,8 @@
 
 #include "core/document_id.hxx"
 
+#include <tao/json/forward.hpp>
+
 #include <cstdint>
 #include <string>
 
@@ -26,6 +28,8 @@ namespace couchbase::core::transactions
 {
 struct doc_record {
   public:
+    static doc_record create_from(const tao::json::value& obj);
+
     doc_record(std::string bucket_name, std::string scope_name, std::string collection_name, std::string id)
       : id_(std::move(bucket_name), std::move(scope_name), std::move(collection_name), std::move(id))
     {
@@ -51,15 +55,6 @@ struct doc_record {
         return id_;
     }
 
-    static doc_record create_from(const tao::json::value& obj)
-    {
-        std::string bucket_name = obj.at(ATR_FIELD_PER_DOC_BUCKET).get_string();
-        std::string scope_name = obj.at(ATR_FIELD_PER_DOC_SCOPE).get_string();
-        std::string collection_name = obj.at(ATR_FIELD_PER_DOC_COLLECTION).get_string();
-        std::string id = obj.at(ATR_FIELD_PER_DOC_ID).get_string();
-        return doc_record(bucket_name, scope_name, collection_name, id);
-    }
-
     template<typename OStream>
     friend OStream& operator<<(OStream& os, const doc_record& dr)
     {
@@ -76,24 +71,3 @@ struct doc_record {
     core::document_id id_;
 };
 } // namespace couchbase::core::transactions
-
-template<>
-struct fmt::formatter<couchbase::core::transactions::doc_record> {
-  public:
-    template<typename ParseContext>
-    constexpr auto parse(ParseContext& ctx)
-    {
-        return ctx.begin();
-    }
-
-    template<typename FormatContext>
-    constexpr auto format(const couchbase::core::transactions::doc_record& r, FormatContext& ctx) const
-    {
-        return format_to(ctx.out(),
-                         "doc_record:{{ bucket: {}, scope: {}, collection: {}, key: {} }}",
-                         r.document_id().bucket(),
-                         r.document_id().scope(),
-                         r.document_id().collection(),
-                         r.document_id().key());
-    }
-};

package/deps/couchbase-cxx-client/core/transactions/internal/doc_record_fmt.hxx

@@ -0,0 +1,41 @@
+/*
+ *     Copyright 2021-Present 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.
+ */
+#pragma once
+
+#include "doc_record.hxx"
+
+#include <fmt/core.h>
+
+template<>
+struct fmt::formatter<couchbase::core::transactions::doc_record> {
+  public:
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    constexpr auto format(const couchbase::core::transactions::doc_record& r, FormatContext& ctx) const
+    {
+        return format_to(ctx.out(),
+                         "doc_record:{{ bucket: {}, scope: {}, collection: {}, key: {} }}",
+                         r.document_id().bucket(),
+                         r.document_id().scope(),
+                         r.document_id().collection(),
+                         r.document_id().key());
+    }
+};

package/deps/couchbase-cxx-client/core/transactions/internal/logging.hxx

@@ -19,27 +19,29 @@
 
 namespace couchbase::core::transactions
 {
-static const std::string txn_format_string("[transactions] - ");
-static const std::string attempt_format_string("[transactions]({}/{}) - ");
-static const std::string lost_attempt_format_string("[lost_attempt_cleanup]({}) - ");
-static const std::string attempt_cleanup_format_string("[attempt_cleanup] - ");
+#define CB_ORIGINAL_FMT(fmt, ...) fmt
+#define CB_ORIGINAL_REST(fmt, ...) __VA_ARGS__
 
 #define CB_TXN_LOG(level, ...) COUCHBASE_LOG(__FILE__, __LINE__, COUCHBASE_LOGGER_FUNCTION, level, __VA_ARGS__)
 
-#define ADD_CTX(ctx, ...) fmt::format(attempt_format_string, ctx->transaction_id(), ctx->id()) + __VA_ARGS__
-#define ADD_LOST_ATTEMPT(ctx, ...) fmt::format(couchbase::core::transactions::lost_attempt_format_string, fmt::ptr(ctx)) + __VA_ARGS__
-#define ADD_ATTEMPT_CLEANUP(...) couchbase::core::transactions::attempt_cleanup_format_string + __VA_ARGS__
-#define ADD_TXN(...) couchbase::core::transactions::txn_format_string + __VA_ARGS__
+#define ADD_CTX(ctx, ...)                                                                                                                  \
+    "[transactions]({}/{}) - " CB_ORIGINAL_FMT(__VA_ARGS__, dmmy), (ctx)->transaction_id(), (ctx)->id(), CB_ORIGINAL_REST(__VA_ARGS__)
+#define ADD_LOST_ATTEMPT(ctx, ...)                                                                                                         \
+    "[lost_attempt_cleanup]({}) - " CB_ORIGINAL_FMT(__VA_ARGS__, dmmy), fmt::ptr(ctx), CB_ORIGINAL_REST(__VA_ARGS__)
+#define ADD_ATTEMPT_CLEANUP(...) "[attempt_cleanup] - " __VA_ARGS__
+#define ADD_TXN(...) "[transactions] - " __VA_ARGS__
 
-#define CB_ATTEMPT_CTX_LOG_TRACE(ctx, ...) CB_TXN_LOG(couchbase::core::logger::level::trace, ADD_CTX(ctx, __VA_ARGS__))
-#define CB_ATTEMPT_CTX_LOG_DEBUG(ctx, ...) CB_TXN_LOG(couchbase::core::logger::level::debug, ADD_CTX(ctx, __VA_ARGS__))
-#define CB_ATTEMPT_CTX_LOG_INFO(ctx, ...) CB_TXN_LOG(couchbase::core::logger::level::info, ADD_CTX(ctx, __VA_ARGS__))
-#define CB_ATTEMPT_CTX_LOG_WARNING(ctx, ...) CB_TXN_LOG(couchbase::core::logger::level::warn, ADD_CTX(ctx, __VA_ARGS__))
-#define CB_ATTEMPT_CTX_LOG_ERROR(ctx, ...) CB_TXN_LOG(couchbase::core::logger::level::err, ADD_CTX(ctx, __VA_ARGS__))
+#define CB_ATTEMPT_CTX_LOG_TRACE(ctx, ...) CB_TXN_LOG(couchbase::core::logger::level::trace, ADD_CTX(ctx, __VA_ARGS__, nullptr))
+#define CB_ATTEMPT_CTX_LOG_DEBUG(ctx, ...) CB_TXN_LOG(couchbase::core::logger::level::debug, ADD_CTX(ctx, __VA_ARGS__, nullptr))
+#define CB_ATTEMPT_CTX_LOG_INFO(ctx, ...) CB_TXN_LOG(couchbase::core::logger::level::info, ADD_CTX(ctx, __VA_ARGS__, nullptr))
+#define CB_ATTEMPT_CTX_LOG_WARNING(ctx, ...) CB_TXN_LOG(couchbase::core::logger::level::warn, ADD_CTX(ctx, __VA_ARGS__, nullptr))
+#define CB_ATTEMPT_CTX_LOG_ERROR(ctx, ...) CB_TXN_LOG(couchbase::core::logger::level::err, ADD_CTX(ctx, __VA_ARGS__, nullptr))
 #define CB_ATTEMPT_CTX_LOG_CRITICAL(ctx, ...) CB_TXN_LOG(couchbase::core::logger::level::critical, ADD_CTX(ctx, __VA_ARGS__))
 
-#define CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE(...) CB_TXN_LOG(couchbase::core::logger::level::trace, ADD_LOST_ATTEMPT(this, __VA_ARGS__))
-#define CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG(...) CB_TXN_LOG(couchbase::core::logger::level::debug, ADD_LOST_ATTEMPT(this, __VA_ARGS__))
+#define CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE(...)                                                                                             \
+    CB_TXN_LOG(couchbase::core::logger::level::trace, ADD_LOST_ATTEMPT(this, __VA_ARGS__, nullptr))
+#define CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG(...)                                                                                             \
+    CB_TXN_LOG(couchbase::core::logger::level::debug, ADD_LOST_ATTEMPT(this, __VA_ARGS__, nullptr))
 #define CB_LOST_ATTEMPT_CLEANUP_LOG_INFO(...) CB_TXN_LOG(couchbase::core::logger::level::info, ADD_LOST_ATTEMPT(this, __VA_ARGS__))
 #define CB_LOST_ATTEMPT_CLEANUP_LOG_WARNING(...) CB_TXN_LOG(couchbase::core::logger::level::warn, ADD_LOST_ATTEMPT(this, __VA_ARGS__))
 #define CB_LOST_ATTEMPT_CLEANUP_LOG_ERROR(...) CB_TXN_LOG(couchbase::core::logger::level::err, ADD_LOST_ATTEMPT(this, __VA_ARGS__))

package/deps/couchbase-cxx-client/core/transactions/internal/transaction_context.hxx

@@ -72,7 +72,7 @@ class transaction_context
         attempts_.back().state = s;
     }
 
-    [[nodiscard]] std::shared_ptr<core::cluster> cluster_ref()
+    [[nodiscard]] const core::cluster& cluster_ref() const
     {
         return transactions_.cluster_ref();
     }

package/deps/couchbase-cxx-client/core/transactions/internal/transactions_cleanup.hxx

@@ -87,10 +87,10 @@ struct atr_cleanup_stats {
 class transactions_cleanup
 {
   public:
-    transactions_cleanup(std::shared_ptr<core::cluster> cluster, const couchbase::transactions::transactions_config::built& config);
+    transactions_cleanup(core::cluster cluster, const couchbase::transactions::transactions_config::built& config);
     ~transactions_cleanup();
 
-    [[nodiscard]] std::shared_ptr<core::cluster> cluster_ref() const
+    [[nodiscard]] const core::cluster& cluster_ref() const
     {
         return cluster_;
     };
@@ -130,7 +130,7 @@ class transactions_cleanup
     void close();
 
   private:
-    std::shared_ptr<core::cluster> cluster_;
+    core::cluster cluster_;
     couchbase::transactions::transactions_config::built config_;
     const std::chrono::milliseconds cleanup_loop_delay_{ 100 };
 
@@ -162,4 +162,4 @@ class transactions_cleanup
     bool running_{ false };
 };
 } // namespace transactions
-} // namespace couchbase::core
+} // namespace couchbase::core

package/deps/couchbase-cxx-client/core/transactions/internal/utils.hxx

@@ -57,30 +57,18 @@ operator<<(OStream& os, const core::document_id& id)
     return os;
 }
 
-template<typename T>
-T&
-wrap_request(T&& req, const couchbase::transactions::transactions_config::built& config)
-{
-    if (config.kv_timeout) {
-        req.timeout = config.kv_timeout.value();
-    }
-    return req;
-}
-
 template<typename T>
 T&
 wrap_durable_request(T&& req, const couchbase::transactions::transactions_config::built& config)
 {
-    wrap_request(req, config);
     req.durability_level = config.level;
     return req;
 }
 
 template<typename T>
 T&
-wrap_durable_request(T&& req, const couchbase::transactions::transactions_config::built& config, durability_level level)
+wrap_durable_request(T&& req, durability_level level)
 {
-    wrap_request(req, config);
     req.durability_level = level;
     return req;
 }
@@ -254,6 +242,7 @@ struct exp_delay {
     std::chrono::nanoseconds timeout;
     mutable std::uint32_t retries;
     mutable std::optional<std::chrono::time_point<std::chrono::steady_clock>> end_time;
+    std::size_t max_retries{ 100 };
 
     template<typename R1, typename P1, typename R2, typename P2, typename R3, typename P3>
     exp_delay(std::chrono::duration<R1, P1> initial, std::chrono::duration<R2, P2> max, std::chrono::duration<R3, P3> limit)
@@ -267,6 +256,9 @@ struct exp_delay {
     void operator()() const
     {
         auto now = std::chrono::steady_clock::now();
+        if (retries >= max_retries) {
+            throw retry_operation_retries_exhausted("retries exhausted");
+        }
         if (!end_time) {
             end_time = std::chrono::steady_clock::now() + timeout;
             return;

package/deps/couchbase-cxx-client/core/transactions/result.hxx

@@ -22,7 +22,6 @@
 
 #include "couchbase/codec/tao_json_serializer.hxx"
 
-#include <fmt/format.h>
 #include <optional>
 #include <string>
 #include <vector>
@@ -269,28 +268,3 @@ struct result : result_base {
 };
 } // namespace transactions
 } // namespace couchbase::core
-
-template<>
-struct fmt::formatter<couchbase::core::transactions::result> {
-  public:
-    template<typename ParseContext>
-    constexpr auto parse(ParseContext& ctx)
-    {
-        return ctx.begin();
-    }
-
-    template<typename FormatContext>
-    constexpr auto format(const couchbase::core::transactions::result& r, FormatContext& ctx) const
-    {
-        return format_to(ctx.out(),
-                         "result:{{ rc: {}, strerror: {}, cas: {}, is_deleted: {}, datatype: {}, flags: {}, raw_value: {:.{}} }}",
-                         r.rc,
-                         r.strerror(),
-                         r.cas,
-                         r.is_deleted,
-                         r.datatype,
-                         r.flags,
-                         couchbase::core::transactions::to_string(r.raw_value),
-                         r.raw_value.size() > 1024 ? 1024 : r.raw_value.size());
-    }
-};

package/deps/couchbase-cxx-client/core/transactions/result_fmt.hxx

@@ -0,0 +1,46 @@
+/*
+ *     Copyright 2021-Present 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.
+ */
+
+#pragma once
+
+#include "result.hxx"
+
+#include <fmt/core.h>
+
+template<>
+struct fmt::formatter<couchbase::core::transactions::result> {
+  public:
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    constexpr auto format(const couchbase::core::transactions::result& r, FormatContext& ctx) const
+    {
+        return format_to(ctx.out(),
+                         "result:{{ rc: {}, strerror: {}, cas: {}, is_deleted: {}, datatype: {}, flags: {}, raw_value: {:.{}} }}",
+                         r.rc,
+                         r.strerror(),
+                         r.cas,
+                         r.is_deleted,
+                         r.datatype,
+                         r.flags,
+                         couchbase::core::transactions::to_string(r.raw_value),
+                         r.raw_value.size() > 1024 ? 1024 : r.raw_value.size());
+    }
+};