couchbase 3.8.1 → 3.9.0

data/ext/couchbase/core/transactions/transactions.cxx

@@ -166,34 +166,6 @@ wrap_run(transactions& txns,
   return overall->get_transaction_result();
 }
 
-template<typename Handler>
-auto
-wrap_public_api_run(transactions& txns,
-                    const couchbase::transactions::transaction_options& config,
-                    std::size_t max_attempts,
-                    Handler&& fn) -> ::couchbase::transactions::transaction_result
-{
-  return wrap_run(txns, config, max_attempts, [fn = std::forward<Handler>(fn)](const auto& ctx) {
-    const couchbase::error err = fn(ctx);
-    if (err && err.ec() != errc::transaction_op::transaction_op_failed) {
-      // We intentionally don't handle transaction_op_failed here, as we must have cached the
-      // transaction error internally already, which has the full context with the right error class
-      // etc.
-      if (err.ec().category() == core::impl::transaction_op_category()) {
-        throw op_exception(err);
-      }
-      throw std::system_error(err.ec(), fmt::format("{}", err));
-    }
-  });
-}
-
-auto
-transactions::run(logic&& code) -> ::couchbase::transactions::transaction_result
-{
-  const couchbase::transactions::transaction_options config;
-  return wrap_run(*this, config, max_attempts_, std::move(code));
-}
-
 auto
 transactions::run(const couchbase::transactions::transaction_options& config, logic&& code)
   -> ::couchbase::transactions::transaction_result
@@ -202,17 +174,9 @@ transactions::run(const couchbase::transactions::transaction_options& config, lo
 }
 
 auto
-transactions::run(couchbase::transactions::txn_logic&& code,
-                  const couchbase::transactions::transaction_options& config)
-  -> std::pair<couchbase::error, couchbase::transactions::transaction_result>
+transactions::run(logic&& code) -> ::couchbase::transactions::transaction_result
 {
-  try {
-    return { {}, wrap_public_api_run(*this, config, max_attempts_, std::move(code)) };
-  } catch (const transaction_exception& e) {
-    // get error from e and return it in the transaction_result
-    auto [err_ctx, result] = e.get_transaction_result();
-    return std::make_pair(core::impl::make_error(err_ctx), result);
-  }
+  return run({}, std::move(code));
 }
 
 void
@@ -229,27 +193,11 @@ transactions::run(const couchbase::transactions::transaction_options& config,
     }
   }).detach();
 }
-void
-transactions::run(couchbase::transactions::async_txn_logic&& code,
-                  couchbase::transactions::async_txn_complete_logic&& cb,
-                  const couchbase::transactions::transaction_options& config)
-{
-  std::thread([this, config, code = std::move(code), cb = std::move(cb)]() {
-    try {
-      auto result = wrap_public_api_run(*this, config, max_attempts_, code);
-      return cb({}, result);
-    } catch (const transaction_exception& e) {
-      auto [ctx, res] = e.get_transaction_result();
-      return cb(core::impl::make_error(ctx), res);
-    }
-  }).detach();
-}
 
 void
 transactions::run(async_logic&& code, txn_complete_callback&& cb)
 {
-  const couchbase::transactions::transaction_options config;
-  return run(config, std::move(code), std::move(cb));
+  return run({}, std::move(code), std::move(cb));
 }
 
 void

data/ext/couchbase/core/transactions/transactions_cleanup.cxx

@@ -27,12 +27,18 @@
 #include "internal/utils.hxx"
 
 #include "core/operations.hxx"
-#include "core/utils/byteswap.hxx"
+#include "core/utils/process_id.hxx"
 
 #include <couchbase/fmt/transaction_keyspace.hxx>
 
+#include <asio/post.hpp>
+
+#include <deque>
 #include <functional>
+#include <future>
+#include <list>
 #include <memory>
+#include <thread>
 #include <utility>
 
 namespace couchbase::core::transactions
@@ -52,34 +58,13 @@ transactions_cleanup::transactions_cleanup(
   : cluster_(std::move(cluster))
   , config_(std::move(config))
   , client_uuid_(uid_generator::next())
+  , client_record_owner_pid_(utils::current_process_id())
 {
   start();
 }
 
 namespace
 {
-/**
- * ${Mutation.CAS} is written by kvengine with
- * 'macroToString(htonll(info.cas))'.  Discussed this with KV team and, though
- * there is consensus that this is off (htonll is definitely wrong, and a string
- * is an odd choice), there are clients (SyncGateway) that consume the current
- * string, so it can't be changed.  Note that only little-endian servers are
- * supported for Couchbase, so the 8 byte long inside the string will always be
- * little-endian ordered.
- *
- * Looks like: "0x000058a71dd25c15"
- * Want:        0x155CD21DA7580000   (1539336197457313792 in base10, an epoch
- * time in millionths of a second)
- */
-auto
-parse_mutation_cas(const std::string& cas) -> std::uint64_t
-{
-  if (cas.empty()) {
-    return 0;
-  }
-  return core::utils::byte_swap(std::stoull(cas, nullptr, 16)) / 1000000;
-}
-
 // TODO(CXXCBC-549)
 const std::string CLIENT_RECORD_DOC_ID = "_txn:client-record"; // NOLINT(cert-err58-cpp)
 } // namespace
@@ -108,7 +93,7 @@ transactions_cleanup::clean_collection(
   // first make sure the collection is in the list
   while (is_running()) {
     {
-      const std::lock_guard<std::mutex> lock(mutex_);
+      const std::scoped_lock<std::mutex> lock(mutex_);
       if (collections_.end() == std::find(collections_.begin(), collections_.end(), keyspace)) {
         CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG(
           "cleanup for {} ending, no longer in collection cleanup list", keyspace);
@@ -131,54 +116,125 @@ transactions_cleanup::clean_collection(
         all_atrs.size(),
         config_.cleanup_config.cleanup_window.count());
 
+      // Each ATR is checked with a blocking get_atr. If those were run strictly one-at-a-time the
+      // scan rate would be capped by the per-ATR KV latency rather than the cleanup window: on a
+      // slow or loaded KV node a single window could fail to scan all ATRs, leaving lost
+      // transactions (and the documents they block) uncleaned for far longer than configured. So
+      // run the checks with a bounded number in flight: launches are still paced across the window
+      // (to avoid flooding the cluster), but a slow lookup no longer holds up the ones behind it.
+      std::deque<std::future<void>> in_flight;
+      // The pool is created in start() whenever lost-attempts cleanup is enabled, which is the only
+      // configuration that spawns collection workers, so it is always present here. Bind a checked
+      // reference now rather than dereferencing the optional at each launch.
+      if (!atr_cleanup_pool_.has_value()) {
+        // Should be unreachable (see above). If the invariant is ever broken, surface it: a silent
+        // return here disables lost-attempts cleanup for this collection with no other signal.
+        CB_LOST_ATTEMPT_CLEANUP_LOG_ERROR(
+          "atr cleanup pool is not initialized; skipping lost-attempts cleanup for {}", keyspace);
+        return;
+      }
+      auto& atr_cleanup_pool = *atr_cleanup_pool_;
+      const auto reclaim_one = [&in_flight]() {
+        const auto reclaim = [](std::future<void>& f) {
+          // get() only rethrows if the task itself threw, which it is written not to, but guard
+          // anyway so one bad ATR cannot abort the whole scan.
+          try {
+            f.get();
+            // NOLINTNEXTLINE(bugprone-empty-catch) -- task already logged any error
+          } catch (...) {
+            // already handled in the task
+          }
+        };
+        // Reclaim any already-finished check first, so a slow lookup at the front does not hold up
+        // the ready ones queued behind it.
+        for (auto it = in_flight.begin(); it != in_flight.end(); ++it) {
+          if (it->wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
+            reclaim(*it);
+            in_flight.erase(it);
+            return;
+          }
+        }
+        // None ready yet: block on the oldest, since a slot must be freed before launching more.
+        reclaim(in_flight.front());
+        in_flight.pop_front();
+      };
+
       for (auto it = all_atrs.begin() + details.index_of_this_client; it < all_atrs.end();
            it += details.num_active_clients) {
-        auto atrs_left_for_this_client =
-          std::distance(it, all_atrs.end()) /
-          std::max<decltype(it)::difference_type>(1, details.num_active_clients);
+        if (!is_running()) {
+          break;
+        }
+        // This client visits every num_active_clients-th ATR from `it`, so the number it still has
+        // to launch is ceil(remaining / stride). Floor division would undercount at the tail,
+        // inflating budget_for_this_atr below and over-pacing the scan past the cleanup window.
+        const auto stride = std::max<decltype(it)::difference_type>(1, details.num_active_clients);
+        const auto atrs_left_for_this_client =
+          (std::distance(it, all_atrs.end()) + stride - 1) / stride;
         const auto now = std::chrono::steady_clock::now();
         const auto elapsed_in_cleanup_window =
           std::chrono::duration_cast<std::chrono::microseconds>(now - start);
         const auto remaining_in_cleanup_window = cleanup_window - elapsed_in_cleanup_window;
+        // Divide the time left in the window evenly among the ATRs still to launch, so the scan is
+        // spread across the window rather than issued as a burst.
         const auto budget_for_this_atr = std::chrono::microseconds(
           remaining_in_cleanup_window.count() /
           std::max<decltype(it)::difference_type>(1, atrs_left_for_this_client));
-        // clean the ATR entry
-        std::string atr_id = *it;
-        if (!is_running()) {
-          CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("cleanup of {} complete", keyspace);
-          return;
-        }
-
-        try {
-          handle_atr_cleanup({ keyspace.bucket, keyspace.scope, keyspace.collection, atr_id });
-        } catch (const std::exception& e) {
-          CB_LOST_ATTEMPT_CLEANUP_LOG_ERROR(
-            "cleanup of atr {} failed with {}, moving on", atr_id, e.what());
+        // Bound concurrency: reclaim a finished slot before launching the next check.
+        while (in_flight.size() >= max_in_flight_atr_checks_) {
+          reclaim_one();
         }
 
-        const auto atr_end = std::chrono::steady_clock::now();
-        const auto atr_used = std::chrono::duration_cast<std::chrono::microseconds>(atr_end - now);
-        const auto atr_left = budget_for_this_atr - atr_used;
-
-        // Too verbose to log, but leaving here commented as it may be useful later for internal
-        // debugging
-        /*CB_LOST_ATTEMPT_CLEANUP_LOG_INFO("{} {} atrs_left_for_this_client={}
-           elapsed_in_cleanup_window={}us " "remaining_in_cleanup_window={}us
-           budget_for_this_atr={}us atr_used={}us atr_left={}us", bucket_name, atr_id,
-           atrs_left_for_this_client, elapsed_in_cleanup_window.count(),
-                                    remaining_in_cleanup_window.count(),
-                                    budget_for_this_atr.count(),
-                                    atr_used.count(),
-                                    atr_left.count());*/
-
-        if (atr_left.count() > 0 &&
-            atr_left.count() < 1000000000) { // safety check protects against bugs
-          if (!interruptable_wait(atr_left)) {
-            return;
+        const std::string atr_id = *it;
+        // Offload the blocking check to the shared bounded pool (never the IO thread); keep its
+        // future so the loop can bound how many run concurrently and drain them at the end.
+        // packaged_task is wrapped in a shared_ptr because asio::post needs a copyable handler.
+        auto task = std::make_shared<std::packaged_task<void()>>([this, keyspace, atr_id]() {
+          try {
+            handle_atr_cleanup({ keyspace.bucket, keyspace.scope, keyspace.collection, atr_id });
+          } catch (const std::exception& e) {
+            CB_LOST_ATTEMPT_CLEANUP_LOG_ERROR(
+              "cleanup of atr {} failed with {}, moving on", atr_id, e.what());
+          }
+        });
+        auto future = task->get_future();
+        // Post before recording the future. If asio::post() throws (e.g. allocation failure) the
+        // task never runs; recording its future first would leave a future in `in_flight` that
+        // never becomes ready, deadlocking reclaim_one()/the drain. On throw, `future` is discarded
+        // and the exception unwinds to the per-collection retry below.
+        asio::post(atr_cleanup_pool, [task]() {
+          (*task)();
+        });
+        in_flight.emplace_back(std::move(future));
+
+        // Pace the launch cadence so the scan spreads across the window rather than bursting.
+        // Subtract the time already spent this iteration -- reclaiming a slot can block on a slow
+        // lookup, and posting takes time -- from the budget, so a slow iteration does not push the
+        // scan past the cleanup window. If we are already behind, the remainder is <= 0 and we
+        // proceed immediately.
+        const auto work_time = std::chrono::duration_cast<std::chrono::microseconds>(
+          std::chrono::steady_clock::now() - now);
+        const auto sleep_for_this_atr = budget_for_this_atr - work_time;
+        if (sleep_for_this_atr.count() > 0 &&
+            sleep_for_this_atr.count() < 1000000000) { // safety check protects against bugs
+          if (!interruptable_wait(sleep_for_this_atr)) {
+            break;
           }
         }
       }
+
+      // Wait for any still-running checks before completing the run. On stop() the launch loop
+      // above has already stopped starting new checks (it breaks on !is_running()), so this only
+      // drains the
+      // <= max_in_flight_atr_checks_ already in flight. They are reclaimed rather than abandoned
+      // because each task references this cleanup state; teardown therefore blocks on them, bounded
+      // by the KV read timeout (an in-flight get_atr is not cancelled).
+      while (!in_flight.empty()) {
+        reclaim_one();
+      }
+      if (!is_running()) {
+        CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("cleanup of {} complete", keyspace);
+        return;
+      }
     } catch (const std::exception& ex) {
       CB_LOST_ATTEMPT_CLEANUP_LOG_ERROR("cleanup failed with {}, trying again in 3 sec...",
                                         ex.what());
@@ -586,10 +642,17 @@ transactions_cleanup::add_collection(const couchbase::transactions::transaction_
     auto it = std::find(collections_.begin(), collections_.end(), keyspace);
     if (it == collections_.end()) {
       collections_.emplace_back(keyspace);
-      // start cleaning right away
-      lost_attempt_cleanup_workers_.emplace_back([this, keyspace = collections_.back()]() {
-        this->clean_collection(keyspace);
-      });
+      // Spawn only while running. stop() takes the worker handles out and joins them, so a
+      // handle appended after that point is one nothing has agreed to join -- and a
+      // joinable std::thread that reaches its destructor terminates. Registering the
+      // keyspace is still right: start() spawns a worker for everything in collections_,
+      // so cleanup resumes for it on the next start.
+      if (running_) {
+        // start cleaning right away
+        lost_attempt_cleanup_workers_.emplace_back([this, keyspace = collections_.back()]() {
+          this->clean_collection(keyspace);
+        });
+      }
     }
     lock.unlock();
     CB_ATTEMPT_CLEANUP_LOG_DEBUG("added {} to lost transaction cleanup", keyspace);
@@ -599,8 +662,41 @@ transactions_cleanup::add_collection(const couchbase::transactions::transaction_
 void
 transactions_cleanup::start()
 {
-  running_ =
-    config_.cleanup_config.cleanup_client_attempts || config_.cleanup_config.cleanup_lost_attempts;
+  // The pool has to exist before any worker does: clean_collection() treats a missing pool
+  // as a broken invariant and gives up on the keyspace.
+  if (config_.cleanup_config.cleanup_lost_attempts) {
+    // Blocking per-ATR checks are offloaded to this bounded pool, never the single IO thread.
+    atr_cleanup_pool_.emplace(max_in_flight_atr_checks_);
+  }
+
+  {
+    // running_ is read under mutex_ everywhere else -- is_running(), interruptable_wait(),
+    // add_collection() and stop() -- so it is written under it here too, rather than being
+    // the one unsynchronized access to it.
+    //
+    // Publishing it in the same critical section as the respawn below also settles who
+    // spawns what. A concurrent add_collection() either runs before this section and only
+    // registers its keyspace, which the loop then spawns for, or after it and spawns for
+    // itself, by which point the loop has already gone past. Exactly one worker per
+    // keyspace either way.
+    const std::unique_lock<std::mutex> lock(mutex_);
+    running_ = config_.cleanup_config.cleanup_client_attempts ||
+               config_.cleanup_config.cleanup_lost_attempts;
+
+    if (config_.cleanup_config.cleanup_lost_attempts) {
+      // Re-spawn a worker for every keyspace still registered from before a previous
+      // stop(). add_collection() below cannot do it: it dedupes on collections_, so
+      // for an already-registered keyspace it skips the worker and lost-attempt
+      // cleanup stays dead for the rest of the process. Any fork leaves exactly that
+      // state behind -- notify_fork(prepare) stops cleanup, notify_fork(parent)
+      // starts it again.
+      for (const auto& keyspace : collections_) {
+        lost_attempt_cleanup_workers_.emplace_back([this, keyspace]() {
+          this->clean_collection(keyspace);
+        });
+      }
+    }
+  }
   if (config_.cleanup_config.cleanup_client_attempts) {
     cleanup_thr_ = std::thread([this] {
       attempts_loop();
@@ -628,12 +724,41 @@ transactions_cleanup::stop()
     cleanup_thr_.join();
     CB_ATTEMPT_CLEANUP_LOG_DEBUG("cleanup attempt thread closed");
   }
-  for (auto& t : lost_attempt_cleanup_workers_) {
+  // Take the handles out under mutex_, then join them with the lock released.
+  //
+  // Under the lock, because add_collection() and start() append to this list while
+  // holding mutex_. Walking it while another thread appends is a data race on the
+  // list itself, and an append that lands after it was emptied would leave a
+  // joinable std::thread to be destroyed later, which terminates.
+  //
+  // With the lock released, because the workers themselves take mutex_ to see
+  // running_ (interruptable_wait, and the collections_ lookup in clean_collection),
+  // so joining while holding it deadlocks.
+  //
+  // Moving the handles out also drops them, which a later start() needs in order to
+  // spawn fresh workers. collections_ is deliberately kept: it also holds keyspaces
+  // registered at runtime, and discarding those would silently stop cleaning them.
+  std::list<std::thread> workers;
+  {
+    const std::unique_lock<std::mutex> lock(mutex_);
+    workers.swap(lost_attempt_cleanup_workers_);
+  }
+  for (auto& t : workers) {
     CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("shutting down all lost attempt threads...");
     if (t.joinable()) {
       t.join();
     }
   }
+  // Workers drain their in-flight checks before returning, so the pool is now idle. stop() before
+  // join(): the pool's threads wait for work, so join() alone would block indefinitely on an idle
+  // pool; stop() requests shutdown so join() returns (there is no pending work left to abandon).
+  // Reset afterwards so stop() is idempotent: close() calls stop() from the destructor and the user
+  // may also call it explicitly, and a joined pool must not be joined again.
+  if (atr_cleanup_pool_) {
+    atr_cleanup_pool_->stop();
+    atr_cleanup_pool_->join();
+    atr_cleanup_pool_.reset();
+  }
 }
 
 void
@@ -641,7 +766,10 @@ transactions_cleanup::close()
 {
   stop();
   CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("all lost attempt cleanup threads closed");
-  remove_client_record_from_all_buckets(client_uuid_);
+  // In a forked child the record is the parent's, and the parent is still registered under it.
+  if (client_record_owner_pid_ == utils::current_process_id()) {
+    remove_client_record_from_all_buckets(client_uuid_);
+  }
 }
 
 transactions_cleanup::~transactions_cleanup()

data/ext/couchbase/core/transactions/transactions_config.cxx

@@ -32,17 +32,6 @@ transactions_config::transactions_config()
 
 transactions_config::~transactions_config() = default;
 
-transactions_config::transactions_config(transactions_config&& c) noexcept
-  : level_(c.level_)
-  , timeout_(c.timeout_)
-  , attempt_context_hooks_(c.attempt_context_hooks_)
-  , cleanup_hooks_(c.cleanup_hooks_)
-  , metadata_collection_(std::move(c.metadata_collection_))
-  , query_config_(c.query_config_)
-  , cleanup_config_(std::move(c.cleanup_config_))
-{
-}
-
 transactions_config::transactions_config(const transactions_config& config)
   : level_(config.durability_level())
   , timeout_(config.timeout())

data/ext/couchbase/core/transactions/utils.cxx

@@ -20,6 +20,7 @@
 #include "core/operations/document_lookup_in.hxx"
 #include "core/operations/management/bucket_get_all.hxx"
 #include "core/transactions/error_class.hxx"
+#include "core/utils/byteswap.hxx"
 
 #include <couchbase/collection.hxx>
 #include <couchbase/scope.hxx>
@@ -53,6 +54,15 @@ now_ns_from_vbucket(const tao::json::value& vbucket) -> std::uint64_t
   return stoull(now_str, nullptr, 10) * 1000000000;
 }
 
+auto
+parse_mutation_cas(const std::string& cas) -> std::uint64_t
+{
+  if (cas.empty()) {
+    return 0;
+  }
+  return core::utils::reverse_bytes(std::stoull(cas, nullptr, 16)) / 1000000;
+}
+
 void
 wrap_collection_call(result& res, const std::function<void(result&)>& call)
 {

data/ext/couchbase/core/transactions/waitable_op_list.hxx

@@ -79,6 +79,15 @@ public:
     // we have the lock.  Block all further ops
     allow_ops_ = false;
   }
+  // Peek at whether query mode has already been entered.  Briefly acquires mutex_ but, unlike
+  // get_mode(), never waits on cv_query_ for the query node to be set, so it returns immediately.
+  // Used by defensive invariant checks: a KV mutation must never be staged once query mode is
+  // entered.
+  auto query_mode_entered() const -> bool
+  {
+    const std::scoped_lock lock(mutex_);
+    return mode_.mode == attempt_mode::modes::QUERY;
+  }
   auto get_mode() -> attempt_mode
   {
     std::unique_lock<std::mutex> lock(mutex_);
@@ -143,8 +152,10 @@ public:
   {
     // when begin work errors out, it is fatal, so reset to kv mode here, allowing
     // rollback to function properly.
-    std::unique_lock<std::mutex> lock;
+    const std::scoped_lock lock(mutex_);
     mode_.mode = attempt_mode::modes::KV;
+    // query_node is intentionally left populated: a retry runs with a fresh waitable_op_list, and
+    // get_mode()'s wait predicate keys on query_node, so clearing it here would serve no purpose.
     cv_query_.notify_all();
   }
 
@@ -158,7 +169,7 @@ public:
   }
   void decrement_in_flight()
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::scoped_lock<std::mutex> lock(mutex_);
     in_flight_--;
     CB_TXN_LOG_TRACE("in_flight decremented to {}", in_flight_);
     assert(in_flight_ >= 0);
@@ -170,7 +181,7 @@ public:
 private:
   void change_count(int32_t val)
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::scoped_lock<std::mutex> lock(mutex_);
     if (allow_ops_) {
       count_ += val;
       if (val > 0) {
@@ -199,6 +210,6 @@ private:
   std::condition_variable cv_ops_;
   std::condition_variable cv_query_;
   std::condition_variable cv_in_flight_;
-  std::mutex mutex_;
+  mutable std::mutex mutex_;
 };
 } // namespace couchbase::core::transactions

data/ext/couchbase/core/transactions.hxx

@@ -127,7 +127,7 @@ using txn_complete_callback =
 /** @brief Main class for creating a transaction
  *
  */
-class transactions : public couchbase::transactions::transactions
+class transactions
 {
 public:
   /**
@@ -182,10 +182,6 @@ public:
   auto run(const couchbase::transactions::transaction_options& config,
            logic&& code) -> couchbase::transactions::transaction_result;
 
-  auto run(::couchbase::transactions::txn_logic&& code,
-           const couchbase::transactions::transaction_options& config)
-    -> std::pair<couchbase::error, couchbase::transactions::transaction_result> override;
-
   /**
    * @brief Run a transaction
    *
@@ -204,9 +200,6 @@ public:
            async_logic&& code,
            txn_complete_callback&& cb);
 
-  void run(couchbase::transactions::async_txn_logic&& code,
-           couchbase::transactions::async_txn_complete_logic&& complete_cb,
-           const couchbase::transactions::transaction_options& config) override;
   /**
    * @internal
    * called internally - will likely move
@@ -279,7 +272,7 @@ public:
   transactions(core::cluster cluster, couchbase::transactions::transactions_config::built config);
   transactions(core::cluster cluster, const couchbase::transactions::transactions_config& config);
 
-  ~transactions() override;
+  ~transactions();
 
 private:
   core::cluster cluster_;
@@ -288,5 +281,12 @@ private:
   const std::size_t max_attempts_{ 1000 };
   const std::chrono::milliseconds min_retry_delay_{ 1 };
 };
+
+// TODO(DC): Can we replace this with something better?
+// This is needed as the performer needs to access the Core API to set hooks, access cleanup-related
+// metrics, which are not exposed in the Public API.
+auto
+get_core_transactions(const std::shared_ptr<couchbase::transactions::transactions>& transactions)
+  -> std::shared_ptr<couchbase::core::transactions::transactions>;
 } // namespace transactions
 } // namespace couchbase::core