couchbase 4.2.1 → 4.2.2

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

@@ -138,9 +138,12 @@ class attempt_context_impl
     void commit_with_query(VoidCallback&& cb);
     void rollback_with_query(VoidCallback&& cb);
 
-    void query_begin_work(std::function<void(std::exception_ptr)>&& cb);
+    void query_begin_work(std::optional<std::string> query_context, std::function<void(std::exception_ptr)>&& cb);
 
-    void do_query(const std::string& statement, const couchbase::transactions::transaction_query_options& opts, QueryCallback&& cb);
+    void do_query(const std::string& statement,
+                  const couchbase::transactions::transaction_query_options& opts,
+                  std::optional<std::string> query_context,
+                  QueryCallback&& cb);
     std::exception_ptr handle_query_error(const core::operations::query_response& resp);
     void wrap_query(const std::string& statement,
                     const couchbase::transactions::transaction_query_options& opts,
@@ -148,6 +151,7 @@ class attempt_context_impl
                     const tao::json::value& txdata,
                     const std::string& hook_point,
                     bool check_expiry,
+                    std::optional<std::string> query_context,
                     std::function<void(std::exception_ptr, core::operations::query_response)>&& cb);
 
     void handle_err_from_callback(std::exception_ptr e)
@@ -155,27 +159,28 @@ class attempt_context_impl
         try {
             throw e;
         } catch (const transaction_operation_failed& ex) {
-            txn_log->error("op callback called a txn operation that threw exception {}", ex.what());
+            CB_ATTEMPT_CTX_LOG_ERROR(this, "op callback called a txn operation that threw exception {}", ex.what());
             op_list_.decrement_ops();
             // presumably that op called op_completed_with_error already, so
             // don't do anything here but swallow it.
         } catch (const async_operation_conflict& op_ex) {
             // the count isn't changed when this is thrown, so just swallow it and log
-            txn_log->error("op callback called a txn operation that threw exception {}", op_ex.what());
+            CB_ATTEMPT_CTX_LOG_ERROR(this, "op callback called a txn operation that threw exception {}", op_ex.what());
         } catch (const op_exception& op_ex) {
-            txn_log->warn("op callback called a txn operation that threw (and didn't handle) a op_exception {}", op_ex.what());
+            CB_ATTEMPT_CTX_LOG_WARNING(
+              this, "op callback called a txn operation that threw (and didn't handle) a op_exception {}", op_ex.what());
             errors_.push_back(
               transaction_operation_failed(error_class_from_external_exception(op_ex.cause()), op_ex.what()).cause(op_ex.cause()));
             op_list_.decrement_ops();
         } catch (const std::exception& std_ex) {
             // if the callback throws something which wasn't handled
             // we just want to handle as a rollback
-            txn_log->error("op callback threw exception {}", std_ex.what());
+            CB_ATTEMPT_CTX_LOG_ERROR(this, "op callback threw exception {}", std_ex.what());
             errors_.push_back(transaction_operation_failed(FAIL_OTHER, std_ex.what()));
             op_list_.decrement_ops();
         } catch (...) {
             // could be something really arbitrary, still...
-            txn_log->error("op callback threw unexpected exception");
+            CB_ATTEMPT_CTX_LOG_ERROR(this, "op callback threw unexpected exception");
             errors_.push_back(transaction_operation_failed(FAIL_OTHER, "unexpected error"));
             op_list_.decrement_ops();
         }
@@ -294,7 +299,7 @@ class attempt_context_impl
             return func();
         } catch (const async_operation_conflict& e) {
             // can't do anything here but log and eat it.
-            error("Attempted to perform txn operation after commit/rollback started: {}", e.what());
+            CB_ATTEMPT_CTX_LOG_ERROR(this, "Attempted to perform txn operation after commit/rollback started: {}", e.what());
             // you cannot call op_completed_with_error, as it tries to decrement
             // the op count, however it didn't successfully increment it, so...
             op_completed_with_error_no_cache(std::move(cb), std::current_exception());
@@ -311,30 +316,6 @@ class attempt_context_impl
         }
     }
 
-    template<typename... Args>
-    void trace(const std::string& fmt, Args... args)
-    {
-        txn_log->trace(attempt_format_string + fmt, this->transaction_id(), this->id(), args...);
-    }
-
-    template<typename... Args>
-    void debug(const std::string& fmt, Args... args)
-    {
-        txn_log->debug(attempt_format_string + fmt, this->transaction_id(), this->id(), args...);
-    }
-
-    template<typename... Args>
-    void info(const std::string& fmt, Args... args)
-    {
-        txn_log->info(attempt_format_string + fmt, this->transaction_id(), this->id(), args...);
-    }
-
-    template<typename... Args>
-    void error(const std::string& fmt, Args... args)
-    {
-        txn_log->error(attempt_format_string + fmt, this->transaction_id(), this->id(), args...);
-    }
-
     std::shared_ptr<core::cluster> cluster_ref();
 
   public:
@@ -382,22 +363,28 @@ class attempt_context_impl
     };
 
     core::operations::query_response do_core_query(const std::string& statement,
-                                                   const couchbase::transactions::transaction_query_options& options) override;
+                                                   const couchbase::transactions::transaction_query_options& options,
+                                                   std::optional<std::string> query_context) override;
 
-    couchbase::transactions::transaction_query_result_ptr do_public_query(
-      const std::string& statement,
-      const couchbase::transactions::transaction_query_options& opts) override;
+    couchbase::transactions::transaction_query_result_ptr do_public_query(const std::string& statement,
+                                                                          const couchbase::transactions::transaction_query_options& opts,
+                                                                          std::optional<std::string> query_context) override;
 
     void query(const std::string& statement,
                const couchbase::transactions::transaction_query_options& options,
+               std::optional<std::string> query_context,
                QueryCallback&& cb) override;
 
     void query(std::string statement,
                couchbase::transactions::transaction_query_options opts,
+               std::optional<std::string> query_context,
                couchbase::transactions::async_query_handler&& handler) override
     {
         query(
-          statement, opts, [handler = std::move(handler)](std::exception_ptr err, std::optional<core::operations::query_response> resp) {
+          statement,
+          opts,
+          query_context,
+          [handler = std::move(handler)](std::exception_ptr err, std::optional<core::operations::query_response> resp) {
               if (err) {
                   try {
                       std::rethrow_exception(err);

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

@@ -192,12 +192,12 @@ class forward_compat
                 auto behavior = b->check(supported);
                 switch (behavior.behavior) {
                     case forward_compat_behavior::FAIL_FAST_TXN:
-                        txn_log->trace("forward compatiblity FAIL_FAST_TXN");
+                        CB_TXN_LOG_TRACE("forward compatiblity FAIL_FAST_TXN");
                         return ex;
                     case forward_compat_behavior::RETRY_TXN:
-                        txn_log->trace("forward compatibility RETRY_TXN");
+                        CB_TXN_LOG_TRACE("forward compatibility RETRY_TXN");
                         if (behavior.retry_delay) {
-                            txn_log->trace("delay {}ms before retrying", behavior.retry_delay->count());
+                            CB_TXN_LOG_TRACE("delay {}ms before retrying", behavior.retry_delay->count());
                             std::this_thread::sleep_for(*behavior.retry_delay);
                         }
                         return ex.retry();
@@ -213,7 +213,7 @@ class forward_compat
     forward_compat(tao::json::value& json)
       : json_(json)
     {
-        txn_log->trace("creating forward_compat from {}", core::utils::json::generate(json_));
+        CB_TXN_LOG_TRACE("creating forward_compat from {}", core::utils::json::generate(json_));
         // parse it into the map
         for (const auto& [key, value] : json_.get_object()) {
             auto stage = create_forward_compat_stage(key);

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

@@ -21,6 +21,7 @@
 #include "logging.hxx"
 
 #include <chrono>
+#include <fmt/format.h>
 #include <memory>
 #include <mutex>
 #include <optional>
@@ -65,19 +66,16 @@ class atr_cleanup_entry
 
     friend class compare_atr_entries;
 
-    void check_atr_and_cleanup(std::shared_ptr<spdlog::logger> logger, transactions_cleanup_attempt* result);
-    void cleanup_docs(std::shared_ptr<spdlog::logger> logger, durability_level dl);
-    void cleanup_entry(std::shared_ptr<spdlog::logger> logger, durability_level dl);
-    void commit_docs(std::shared_ptr<spdlog::logger> logger, std::optional<std::vector<doc_record>> docs, durability_level dl);
-    void remove_docs(std::shared_ptr<spdlog::logger> logger, std::optional<std::vector<doc_record>> docs, durability_level dl);
-    void remove_docs_staged_for_removal(std::shared_ptr<spdlog::logger> logger,
-                                        std::optional<std::vector<doc_record>> docs,
-                                        durability_level dl);
-    void remove_txn_links(std::shared_ptr<spdlog::logger> logger, std::optional<std::vector<doc_record>> docs, durability_level dl);
-    void do_per_doc(std::shared_ptr<spdlog::logger> logger,
-                    std::vector<doc_record> docs,
+    void check_atr_and_cleanup(transactions_cleanup_attempt* result);
+    void cleanup_docs(durability_level dl);
+    void cleanup_entry(durability_level dl);
+    void commit_docs(std::optional<std::vector<doc_record>> docs, durability_level dl);
+    void remove_docs(std::optional<std::vector<doc_record>> docs, durability_level dl);
+    void remove_docs_staged_for_removal(std::optional<std::vector<doc_record>> docs, durability_level dl);
+    void remove_txn_links(std::optional<std::vector<doc_record>> docs, durability_level dl);
+    void do_per_doc(std::vector<doc_record> docs,
                     bool require_crc_to_match,
-                    const std::function<void(std::shared_ptr<spdlog::logger>, transaction_get_result&, bool)>& call);
+                    const std::function<void(transaction_get_result&, bool)>& call);
 
   public:
     explicit atr_cleanup_entry(attempt_context& ctx);
@@ -88,8 +86,27 @@ class atr_cleanup_entry
 
     explicit atr_cleanup_entry(const core::document_id& atr_id, const std::string& attempt_id, const transactions_cleanup& cleanup);
 
-    void clean(std::shared_ptr<spdlog::logger> logger, transactions_cleanup_attempt* result = nullptr);
+    void clean(transactions_cleanup_attempt* result = nullptr);
     bool ready() const;
+    couchbase::core::document_id atr_id() const
+    {
+        return atr_id_;
+    }
+
+    std::string attempt_id() const
+    {
+        return attempt_id_;
+    }
+
+    bool check_if_expired() const
+    {
+        return check_if_expired_;
+    }
+
+    std::chrono::time_point<std::chrono::steady_clock> min_start_time() const
+    {
+        return min_start_time_;
+    };
 
     template<typename OStream>
     friend OStream& operator<<(OStream& os, const atr_cleanup_entry& e)
@@ -124,3 +141,24 @@ class atr_cleanup_queue
 };
 
 } // namespace couchbase::core::transactions
+
+template<>
+struct fmt::formatter<couchbase::core::transactions::atr_cleanup_entry> {
+  public:
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const couchbase::core::transactions::atr_cleanup_entry& e, FormatContext& ctx) const
+    {
+        return format_to(ctx.out(),
+                         "atr_cleanup_entry{{ atr_id: {}, attempt_id: {}, check_if_expired: {}, min_start_time: {} }}",
+                         e.atr_id(),
+                         e.attempt_id(),
+                         e.check_if_expired(),
+                         std::chrono::duration_cast<std::chrono::milliseconds>(e.min_start_time().time_since_epoch()).count());
+    }
+};

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

@@ -15,6 +15,7 @@
  */
 #pragma once
 
+#include <fmt/format.h>
 #include <string>
 #include <vector>
 
@@ -56,5 +57,29 @@ struct client_record_details {
         return os;
     }
 };
-
 } // namespace couchbase::core::transactions
+template<>
+struct fmt::formatter<couchbase::core::transactions::client_record_details> {
+  public:
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const couchbase::core::transactions::client_record_details& r, FormatContext& ctx) const
+    {
+        return format_to(ctx.out(),
+                         "client_record:{{ client_uuid:: {}, active_clients: {}, index_of_this_client: {}, existing_clients: {}, "
+                         "expired_clients: {}, override_enabled: {}, override_expires: {}, cas_now_nanos: {} }}",
+                         r.client_uuid,
+                         r.num_active_clients,
+                         r.index_of_this_client,
+                         r.num_existing_clients,
+                         r.num_expired_clients,
+                         r.override_enabled,
+                         r.override_expires,
+                         r.cas_now_nanos);
+    }
+};

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

@@ -76,3 +76,24 @@ 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/logging.hxx

@@ -15,26 +15,48 @@
  */
 #pragma once
 
-#include <spdlog/fmt/ostr.h>
-#include <spdlog/logger.h>
-
-#define TXN_LOG "transactions"
-#define ATTEMPT_CLEANUP_LOG "attempt_cleanup"
-#define LOST_ATTEMPT_CLEANUP_LOG "lost_attempt_cleanup"
+#include <core/logger/logger.hxx>
 
 namespace couchbase::core::transactions
 {
-static const std::string attempt_format_string("[{}/{}]:");
-
-std::shared_ptr<spdlog::logger>
-init_txn_log();
-std::shared_ptr<spdlog::logger>
-init_attempt_cleanup_log();
-std::shared_ptr<spdlog::logger>
-init_lost_attempts_log();
-
-static std::shared_ptr<spdlog::logger> txn_log = init_txn_log();
-static std::shared_ptr<spdlog::logger> attempt_cleanup_log = init_attempt_cleanup_log();
-static std::shared_ptr<spdlog::logger> lost_attempts_cleanup_log = init_lost_attempts_log();
+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_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 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_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_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__))
+#define CB_LOST_ATTEMPT_CLEANUP_LOG_CRITICAL(...) CB_TXN_LOG(couchbase::core::logger::level::critical, ADD_LOST_ATTEMPT(this, __VA_ARGS__))
+
+#define CB_ATTEMPT_CLEANUP_LOG_TRACE(...) CB_TXN_LOG(couchbase::core::logger::level::trace, ADD_ATTEMPT_CLEANUP(__VA_ARGS__))
+#define CB_ATTEMPT_CLEANUP_LOG_DEBUG(...) CB_TXN_LOG(couchbase::core::logger::level::debug, ADD_ATTEMPT_CLEANUP(__VA_ARGS__))
+#define CB_ATTEMPT_CLEANUP_LOG_INFO(...) CB_TXN_LOG(couchbase::core::logger::level::info, ADD_ATTEMPT_CLEANUP(__VA_ARGS__))
+#define CB_ATTEMPT_CLEANUP_LOG_WARNING(...) CB_TXN_LOG(couchbase::core::logger::level::warn, ADD_ATTEMPT_CLEANUP(__VA_ARGS__))
+#define CB_ATTEMPT_CLEANUP_LOG_ERROR(...) CB_TXN_LOG(couchbase::core::logger::level::err, ADD_ATTEMPT_CLEANUP(__VA_ARGS__))
+#define CB_ATTEMPT_CLEANUP_LOG_CRITICAL(...) CB_TXN_LOG(couchbase::core::logger::level::critical, ADD_ATTEMPT_CLEANUP(__VA_ARGS__))
+
+#define CB_TXN_LOG_TRACE(...) CB_TXN_LOG(couchbase::core::logger::level::trace, ADD_TXN(__VA_ARGS__))
+#define CB_TXN_LOG_DEBUG(...) CB_TXN_LOG(couchbase::core::logger::level::debug, ADD_TXN(__VA_ARGS__))
+#define CB_TXN_LOG_INFO(...) CB_TXN_LOG(couchbase::core::logger::level::info, ADD_TXN(__VA_ARGS__))
+#define CB_TXN_LOG_WARNING(...) CB_TXN_LOG(couchbase::core::logger::level::warn, ADD_TXN(__VA_ARGS__))
+#define CB_TXN_LOG_ERROR(...) CB_TXN_LOG(couchbase::core::logger::level::err, ADD_TXN(__VA_ARGS__))
+#define CB_TXN_LOG_CRITICAL(...) CB_TXN_LOG(couchbase::core::logger::level::critical, ADD_TXN(__VA_ARGS__))
 
 } // namespace couchbase::core::transactions

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

@@ -149,6 +149,11 @@ class transaction_context
 
     void remove(const transaction_get_result& doc, async_attempt_context::VoidCallback&& cb);
 
+    void query(const std::string& statement,
+               const couchbase::transactions::transaction_query_options& opts,
+               std::optional<std::string> query_context,
+               async_attempt_context::QueryCallback&& cb);
+
     void query(const std::string& statement,
                const couchbase::transactions::transaction_query_options& opts,
                async_attempt_context::QueryCallback&& cb);

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

@@ -22,6 +22,7 @@
 
 #include "couchbase/codec/tao_json_serializer.hxx"
 
+#include <fmt/format.h>
 #include <optional>
 #include <string>
 #include <vector>
@@ -268,3 +269,28 @@ 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());
+    }
+};