couchbase 4.2.1 → 4.2.3

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

@@ -46,9 +46,8 @@ transactions_cleanup::transactions_cleanup(std::shared_ptr<core::cluster> cluste
   : cluster_(cluster)
   , config_(config)
   , client_uuid_(uid_generator::next())
-  , running_(false)
+  , running_(config.cleanup_config.cleanup_client_attempts || config.cleanup_config.cleanup_lost_attempts)
 {
-    running_ = config.cleanup_config.cleanup_client_attempts || config.cleanup_config.cleanup_lost_attempts;
     if (config.cleanup_config.cleanup_client_attempts) {
         cleanup_thr_ = std::thread(std::bind(&transactions_cleanup::attempts_loop, this));
     }
@@ -61,15 +60,14 @@ transactions_cleanup::transactions_cleanup(std::shared_ptr<core::cluster> cluste
     }
 }
 
-static uint64_t
-byteswap64(uint64_t val)
+static std::uint64_t
+byteswap64(std::uint64_t val)
 {
-    std::size_t ii;
-    uint64_t ret = 0;
-    for (ii = 0; ii < sizeof(uint64_t); ii++) {
-        ret <<= 8ull;
-        ret |= val & 0xffull;
-        val >>= 8ull;
+    std::uint64_t ret = 0;
+    for (std::size_t ii = 0; ii < sizeof(std::uint64_t); ii++) {
+        ret <<= 8ULL;
+        ret |= val & 0xffULL;
+        val >>= 8ULL;
     }
     return ret;
 }
@@ -87,7 +85,7 @@ byteswap64(uint64_t val)
  * Want:        0x155CD21DA7580000   (1539336197457313792 in base10, an epoch
  * time in millionths of a second)
  */
-static uint64_t
+static std::uint64_t
 parse_mutation_cas(const std::string& cas)
 {
     if (cas.empty()) {
@@ -115,27 +113,26 @@ transactions_cleanup::interruptable_wait(std::chrono::duration<R, P> delay)
 {
     // wait for specified time, _or_ until the condition variable changes
     std::unique_lock<std::mutex> lock(mutex_);
-    if (!running_.load()) {
+    if (!running_) {
         return false;
     }
-    cv_.wait_for(lock, delay, [&]() { return !running_.load(); });
-    return running_.load();
+    cv_.wait_for(lock, delay, [&]() { return !running_; });
+    return running_;
 }
 
 void
 transactions_cleanup::clean_collection(const couchbase::transactions::transaction_keyspace& keyspace)
 {
     // first make sure the collection is in the list
-    while (running_.load()) {
+    while (is_running()) {
         {
             std::lock_guard<std::mutex> lock(mutex_);
             if (collections_.end() == std::find(collections_.begin(), collections_.end(), keyspace)) {
-                lost_attempts_cleanup_log->info(
-                  "{} cleanup for {} ending, no longer in collection cleanup list", static_cast<void*>(this), keyspace);
+                CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("cleanup for {} ending, no longer in collection cleanup list", keyspace);
                 return;
             }
         }
-        lost_attempts_cleanup_log->info("{} cleanup for {} starting", static_cast<void*>(this), keyspace);
+        CB_LOST_ATTEMPT_CLEANUP_LOG_INFO("cleanup for {} starting", keyspace);
         // we are running, and collection is in the list, so lets clean it.
         try {
             auto details = get_active_clients(keyspace, client_uuid_);
@@ -145,11 +142,10 @@ transactions_cleanup::clean_collection(const couchbase::transactions::transactio
             std::chrono::microseconds cleanup_window =
               std::chrono::duration_cast<std::chrono::microseconds>(config_.cleanup_config.cleanup_window);
             auto start = std::chrono::steady_clock::now();
-            lost_attempts_cleanup_log->info("{} {} active clients (including this one), {} ATRs to check in {}ms",
-                                            static_cast<void*>(this),
-                                            details.num_active_clients,
-                                            all_atrs.size(),
-                                            config_.cleanup_config.cleanup_window.count());
+            CB_LOST_ATTEMPT_CLEANUP_LOG_INFO("{} active clients (including this one), {} ATRs to check in {}ms",
+                                             details.num_active_clients,
+                                             all_atrs.size(),
+                                             config_.cleanup_config.cleanup_window.count());
 
             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 =
@@ -161,16 +157,15 @@ transactions_cleanup::clean_collection(const couchbase::transactions::transactio
                   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 (!running_.load()) {
-                    lost_attempts_cleanup_log->debug("{} cleanup of {} complete", static_cast<void*>(this), keyspace);
+                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) {
-                    lost_attempts_cleanup_log->error(
-                      "{} cleanup of atr {} failed with {}, moving on", static_cast<void*>(this), atr_id, e.what());
+                    CB_LOST_ATTEMPT_CLEANUP_LOG_ERROR("cleanup of atr {} failed with {}, moving on", atr_id, e.what());
                 }
 
                 auto atr_end = std::chrono::steady_clock::now();
@@ -178,7 +173,7 @@ transactions_cleanup::clean_collection(const couchbase::transactions::transactio
                 std::chrono::microseconds 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
-                /*lost_attempts_cleanup_log->info("{} {} atrs_left_for_this_client={} elapsed_in_cleanup_window={}us "
+                /*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,
@@ -190,11 +185,13 @@ transactions_cleanup::clean_collection(const couchbase::transactions::transactio
                                             atr_left.count());*/
 
                 if (atr_left.count() > 0 && atr_left.count() < 1000000000) { // safety check protects against bugs
-                    std::this_thread::sleep_for(atr_left);
+                    if (!interruptable_wait(atr_left)) {
+                        return;
+                    }
                 }
             }
         } catch (const std::exception& ex) {
-            lost_attempts_cleanup_log->error("{} cleanup failed with {}, trying again in 3 sec...", static_cast<void*>(this), ex.what());
+            CB_LOST_ATTEMPT_CLEANUP_LOG_ERROR("cleanup failed with {}, trying again in 3 sec...", ex.what());
             // we must have gotten an exception trying to get the client records.   Let's wait 3 sec and try again
             std::this_thread::sleep_for(std::chrono::seconds(3));
         }
@@ -216,17 +213,16 @@ transactions_cleanup::handle_atr_cleanup(const core::document_id& atr_id, std::v
             // check_if_expired to false.
             atr_cleanup_entry cleanup_entry(entry, atr_id, *this, results == nullptr);
             try {
-                if (results) {
+                if (results != nullptr) {
                     results->emplace_back(cleanup_entry);
                 }
-                cleanup_entry.clean(lost_attempts_cleanup_log, results ? &results->back() : nullptr);
-                if (results) {
+                cleanup_entry.clean(results != nullptr ? &results->back() : nullptr);
+                if (results != nullptr) {
                     results->back().success(true);
                 }
             } catch (const std::exception& e) {
-                lost_attempts_cleanup_log->error(
-                  "{} cleanup of {} failed: {}, moving on", static_cast<void*>(this), cleanup_entry, e.what());
-                if (results) {
+                CB_LOST_ATTEMPT_CLEANUP_LOG_ERROR("cleanup of {} failed: {}, moving on", cleanup_entry, e.what());
+                if (results != nullptr) {
                     results->back().success(false);
                 }
             }
@@ -263,11 +259,11 @@ transactions_cleanup::create_client_record(const couchbase::transactions::transa
         wrap_operation_future(f);
 
     } catch (const client_error& e) {
-        lost_attempts_cleanup_log->trace("{} create_client_record got error {}", static_cast<void*>(this), e.what());
+        CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE("create_client_record got error {}", e.what());
         auto ec = e.ec();
         switch (ec) {
             case FAIL_DOC_ALREADY_EXISTS:
-                lost_attempts_cleanup_log->trace("{} client record already exists, moving on", static_cast<void*>(this));
+                CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE("client record already exists, moving on");
                 return;
             default:
                 throw;
@@ -278,135 +274,127 @@ transactions_cleanup::create_client_record(const couchbase::transactions::transa
 const client_record_details
 transactions_cleanup::get_active_clients(const couchbase::transactions::transaction_keyspace& keyspace, const std::string& uuid)
 {
-    std::chrono::milliseconds min_retry(1000);
-    if (config_.cleanup_config.cleanup_window < min_retry) {
-        min_retry = config_.cleanup_config.cleanup_window;
-    }
-    return retry_op_exponential_backoff_timeout<client_record_details>(
-      min_retry, std::chrono::seconds(1), config_.cleanup_config.cleanup_window, [this, keyspace, uuid]() -> client_record_details {
-          client_record_details details;
-          // Write our client record, return details.
-          try {
-              auto id = document_id{ keyspace.bucket, keyspace.scope, keyspace.collection, CLIENT_RECORD_DOC_ID };
-              core::operations::lookup_in_request req{ id };
-              req.specs =
-                lookup_in_specs{
-                    lookup_in_specs::get(FIELD_RECORDS).xattr(),
-                    lookup_in_specs::get(subdoc::lookup_in_macro::vbucket).xattr(),
-                }
-                  .specs();
-              wrap_request(req, config_);
-              auto barrier = std::make_shared<std::promise<result>>();
-              auto f = barrier->get_future();
-              auto ec = config_.cleanup_hooks->client_record_before_get(keyspace.bucket);
-              if (ec) {
-                  throw client_error(*ec, "client_record_before_get hook raised error");
-              }
-              cluster_->execute(req, [barrier](core::operations::lookup_in_response resp) {
-                  barrier->set_value(result::create_from_subdoc_response(resp));
-              });
-              auto res = wrap_operation_future(f);
-              std::vector<std::string> active_client_uids;
-              auto hlc = res.values[1].content_as();
-              auto now_ms = now_ns_from_vbucket(hlc) / 1000000;
-              details.override_enabled = false;
-              details.override_expires = 0;
-              if (res.values[0].status == subdoc_result::status_type::success) {
-                  auto records = res.values[0].content_as();
-                  lost_attempts_cleanup_log->trace("client records: {}", core::utils::json::generate(records));
-                  for (const auto& [key, value] : records.get_object()) {
-                      if (key == FIELD_OVERRIDE) {
-                          for (const auto& [override, param] : value.get_object()) {
-                              if (override == FIELD_OVERRIDE_ENABLED) {
-                                  details.override_enabled = param.get_boolean();
-                              } else if (override == FIELD_OVERRIDE_EXPIRES) {
-                                  details.override_expires = param.as<std::uint64_t>();
-                              }
-                          }
-                      } else if (key == FIELD_CLIENTS_ONLY) {
-                          for (const auto& [other_client_uuid, cl] : value.get_object()) {
-                              uint64_t heartbeat_ms = parse_mutation_cas(cl.at(FIELD_HEARTBEAT).get_string());
-                              auto expires_ms = cl.at(FIELD_EXPIRES).as<std::uint64_t>();
-                              auto expired_period = static_cast<int64_t>(now_ms) - static_cast<int64_t>(heartbeat_ms);
-                              bool has_expired = expired_period >= static_cast<int64_t>(expires_ms) && now_ms > heartbeat_ms;
-                              if (has_expired && other_client_uuid != uuid) {
-                                  details.expired_client_ids.push_back(other_client_uuid);
-                              } else {
-                                  active_client_uids.push_back(other_client_uuid);
-                              }
-                          }
-                      }
-                  }
-              }
-              if (std::find(active_client_uids.begin(), active_client_uids.end(), uuid) == active_client_uids.end()) {
-                  active_client_uids.push_back(uuid);
-              }
-              std::sort(active_client_uids.begin(), active_client_uids.end());
-              auto this_idx =
-                std::distance(active_client_uids.begin(), std::find(active_client_uids.begin(), active_client_uids.end(), uuid));
-              details.num_active_clients = static_cast<std::uint32_t>(active_client_uids.size());
-              details.index_of_this_client = static_cast<std::uint32_t>(this_idx);
-              details.num_active_clients = static_cast<std::uint32_t>(active_client_uids.size());
-              details.num_expired_clients = static_cast<std::uint32_t>(details.expired_client_ids.size());
-              details.num_existing_clients = details.num_expired_clients + details.num_active_clients;
-              details.client_uuid = uuid;
-              details.cas_now_nanos = now_ms * 1000000;
-              details.override_active = (details.override_enabled && details.override_expires > details.cas_now_nanos);
-              lost_attempts_cleanup_log->trace("{} client details {}", static_cast<void*>(this), details);
-              if (details.override_active) {
-                  lost_attempts_cleanup_log->trace("{} override enabled, will not update record", static_cast<void*>(this));
-                  return details;
-              }
-
-              // update client record, maybe cleanup some as well...
-              core::operations::mutate_in_request mutate_req{ id };
-              auto mut_specs = couchbase::mutate_in_specs{
-                  couchbase::mutate_in_specs::upsert(FIELD_CLIENTS + "." + uuid + "." + FIELD_HEARTBEAT, subdoc::mutate_in_macro::cas)
-                    .xattr()
-                    .create_path(),
-                  couchbase::mutate_in_specs::upsert(FIELD_CLIENTS + "." + uuid + "." + FIELD_EXPIRES,
-                                                     config_.cleanup_config.cleanup_window.count() / 2 + SAFETY_MARGIN_EXPIRY_MS)
-                    .xattr()
-                    .create_path(),
-                  couchbase::mutate_in_specs::upsert(FIELD_CLIENTS + "." + uuid + "." + FIELD_NUM_ATRS, atr_ids::all().size())
-                    .xattr()
-                    .create_path(),
-              };
-              for (std::size_t idx = 0; idx < std::min(details.expired_client_ids.size(), static_cast<std::size_t>(12)); idx++) {
-                  lost_attempts_cleanup_log->trace("adding {} to list of clients to be removed when updating this client",
-                                                   details.expired_client_ids[idx]);
-                  mut_specs.push_back(couchbase::mutate_in_specs::remove(FIELD_CLIENTS + "." + details.expired_client_ids[idx]).xattr());
-              }
-              mutate_req.specs = mut_specs.specs();
-              ec = config_.cleanup_hooks->client_record_before_update(keyspace.bucket);
-              if (ec) {
-                  throw client_error(*ec, "client_record_before_update hook raised error");
-              }
-              wrap_durable_request(mutate_req, config_);
-              auto mutate_barrier = std::make_shared<std::promise<result>>();
-              auto mutate_f = mutate_barrier->get_future();
-              lost_attempts_cleanup_log->trace("updating record");
-              cluster_->execute(mutate_req, [mutate_barrier](core::operations::mutate_in_response resp) {
-                  mutate_barrier->set_value(result::create_from_subdoc_response(resp));
-              });
-              res = wrap_operation_future(mutate_f);
-
-              // just update the cas, and return the details
-              details.cas_now_nanos = res.cas;
-              lost_attempts_cleanup_log->debug("{} get_active_clients found {}", static_cast<void*>(this), details);
-              return details;
-          } catch (const client_error& e) {
-              auto ec = e.ec();
-              switch (ec) {
-                  case FAIL_DOC_NOT_FOUND:
-                      lost_attempts_cleanup_log->debug("{} client record not found, creating new one", static_cast<void*>(this));
-                      create_client_record(keyspace);
-                      throw retry_operation("Client record didn't exist. Creating and retrying");
-                  default:
-                      throw; // retry_operation(fmt::format("got error '' while processing client record, retrying...", e.what()));
-              }
+    client_record_details details;
+    // Write our client record, return details.
+    try {
+        auto id = document_id{ keyspace.bucket, keyspace.scope, keyspace.collection, CLIENT_RECORD_DOC_ID };
+        core::operations::lookup_in_request req{ id };
+        req.specs =
+          lookup_in_specs{
+              lookup_in_specs::get(FIELD_RECORDS).xattr(),
+              lookup_in_specs::get(subdoc::lookup_in_macro::vbucket).xattr(),
           }
-      });
+            .specs();
+        wrap_request(req, config_);
+        auto barrier = std::make_shared<std::promise<result>>();
+        auto f = barrier->get_future();
+        auto ec = config_.cleanup_hooks->client_record_before_get(keyspace.bucket);
+        if (ec) {
+            throw client_error(*ec, "client_record_before_get hook raised error");
+        }
+        cluster_->execute(
+          req, [barrier](core::operations::lookup_in_response resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
+        auto res = wrap_operation_future(f);
+
+        std::vector<std::string> active_client_uids;
+        auto hlc = res.values[1].content_as();
+        auto now_ms = now_ns_from_vbucket(hlc) / 1000000;
+        details.override_enabled = false;
+        details.override_expires = 0;
+        if (res.values[0].status == subdoc_result::status_type::success) {
+            auto records = res.values[0].content_as();
+            CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE("client records: {}", core::utils::json::generate(records));
+            for (const auto& [key, value] : records.get_object()) {
+                if (key == FIELD_OVERRIDE) {
+                    for (const auto& [over_ride, param] : value.get_object()) {
+                        if (over_ride == FIELD_OVERRIDE_ENABLED) {
+                            details.override_enabled = param.get_boolean();
+                        } else if (over_ride == FIELD_OVERRIDE_EXPIRES) {
+                            details.override_expires = param.as<std::uint64_t>();
+                        }
+                    }
+                } else if (key == FIELD_CLIENTS_ONLY) {
+                    for (const auto& [other_client_uuid, cl] : value.get_object()) {
+                        std::uint64_t heartbeat_ms = parse_mutation_cas(cl.at(FIELD_HEARTBEAT).get_string());
+                        auto expires_ms = cl.at(FIELD_EXPIRES).as<std::uint64_t>();
+                        auto expired_period = static_cast<std::int64_t>(now_ms) - static_cast<std::int64_t>(heartbeat_ms);
+                        bool has_expired = expired_period >= static_cast<std::int64_t>(expires_ms) && now_ms > heartbeat_ms;
+                        if (has_expired && other_client_uuid != uuid) {
+                            details.expired_client_ids.push_back(other_client_uuid);
+                        } else {
+                            active_client_uids.push_back(other_client_uuid);
+                        }
+                    }
+                }
+            }
+        }
+        if (std::find(active_client_uids.begin(), active_client_uids.end(), uuid) == active_client_uids.end()) {
+            active_client_uids.push_back(uuid);
+        }
+        std::sort(active_client_uids.begin(), active_client_uids.end());
+        auto this_idx = std::distance(active_client_uids.begin(), std::find(active_client_uids.begin(), active_client_uids.end(), uuid));
+        details.num_active_clients = static_cast<std::uint32_t>(active_client_uids.size());
+        details.index_of_this_client = static_cast<std::uint32_t>(this_idx);
+        details.num_active_clients = static_cast<std::uint32_t>(active_client_uids.size());
+        details.num_expired_clients = static_cast<std::uint32_t>(details.expired_client_ids.size());
+        details.num_existing_clients = details.num_expired_clients + details.num_active_clients;
+        details.client_uuid = uuid;
+        details.cas_now_nanos = now_ms * 1000000;
+        details.override_active = (details.override_enabled && details.override_expires > details.cas_now_nanos);
+        CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE("client details {}", details);
+        if (details.override_active) {
+            CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE("override enabled, will not update record");
+            return details;
+        }
+
+        // update client record, maybe cleanup some as well...
+        core::operations::mutate_in_request mutate_req{ id };
+        auto mut_specs = couchbase::mutate_in_specs{
+            couchbase::mutate_in_specs::upsert(FIELD_CLIENTS + "." + uuid + "." + FIELD_HEARTBEAT, subdoc::mutate_in_macro::cas)
+              .xattr()
+              .create_path(),
+            couchbase::mutate_in_specs::upsert(FIELD_CLIENTS + "." + uuid + "." + FIELD_EXPIRES,
+                                               config_.cleanup_config.cleanup_window.count() / 2 + SAFETY_MARGIN_EXPIRY_MS)
+              .xattr()
+              .create_path(),
+            couchbase::mutate_in_specs::upsert(FIELD_CLIENTS + "." + uuid + "." + FIELD_NUM_ATRS, atr_ids::all().size())
+              .xattr()
+              .create_path(),
+        };
+        for (std::size_t idx = 0; idx < std::min(details.expired_client_ids.size(), static_cast<std::size_t>(12)); idx++) {
+            CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE("adding {} to list of clients to be removed when updating this client",
+                                              details.expired_client_ids[idx]);
+            mut_specs.push_back(couchbase::mutate_in_specs::remove(FIELD_CLIENTS + "." + details.expired_client_ids[idx]).xattr());
+        }
+        mutate_req.specs = mut_specs.specs();
+        ec = config_.cleanup_hooks->client_record_before_update(keyspace.bucket);
+        if (ec) {
+            throw client_error(*ec, "client_record_before_update hook raised error");
+        }
+        wrap_durable_request(mutate_req, config_);
+        auto mutate_barrier = std::make_shared<std::promise<result>>();
+        auto mutate_f = mutate_barrier->get_future();
+        CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE("updating record");
+        cluster_->execute(mutate_req, [mutate_barrier](core::operations::mutate_in_response resp) {
+            mutate_barrier->set_value(result::create_from_subdoc_response(resp));
+        });
+        res = wrap_operation_future(mutate_f);
+
+        // just update the cas, and return the details
+        details.cas_now_nanos = res.cas;
+        CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("get_active_clients found {}", details);
+        return details;
+    } catch (const client_error& e) {
+        auto ec = e.ec();
+        switch (ec) {
+            case FAIL_DOC_NOT_FOUND:
+                CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("client record not found, creating new one");
+                create_client_record(keyspace);
+                return get_active_clients(keyspace, uuid);
+            default:
+                throw;
+        }
+    }
 }
 
 void
@@ -417,9 +405,7 @@ transactions_cleanup::remove_client_record_from_all_buckets(const std::string& u
             retry_op_exponential_backoff_timeout<void>(
               std::chrono::milliseconds(10), std::chrono::milliseconds(250), std::chrono::milliseconds(500), [this, keyspace, uuid]() {
                   try {
-                      // insure a client record document exists...
-                      create_client_record(keyspace);
-                      // now, proceed to remove the client uuid if it exists
+                      // proceed to remove the client uuid if it exists
                       auto ec = config_.cleanup_hooks->client_record_before_remove_client(keyspace.bucket);
                       if (ec) {
                           throw client_error(*ec, "client_record_before_remove_client hook raised error");
@@ -438,17 +424,16 @@ transactions_cleanup::remove_client_record_from_all_buckets(const std::string& u
                           barrier->set_value(result::create_from_subdoc_response(resp));
                       });
                       wrap_operation_future(f);
-                      lost_attempts_cleanup_log->debug("{} removed {} from {}", static_cast<void*>(this), uuid, keyspace);
+                      CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("removed {} from {}", uuid, keyspace);
                   } catch (const client_error& e) {
-                      lost_attempts_cleanup_log->debug("{} error removing client records {}", static_cast<void*>(this), e.what());
+                      CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("error removing client records {}", e.what());
                       auto ec = e.ec();
                       switch (ec) {
                           case FAIL_DOC_NOT_FOUND:
-                              lost_attempts_cleanup_log->debug("{} no client record in {}, ignoring", static_cast<void*>(this), keyspace);
+                              CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("no client record in {}, ignoring", keyspace);
                               return;
                           case FAIL_PATH_NOT_FOUND:
-                              lost_attempts_cleanup_log->debug(
-                                "{} client {} not in client record for {}, ignoring", static_cast<void*>(this), uuid, keyspace);
+                              CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("client {} not in client record for {}, ignoring", uuid, keyspace);
                               return;
                           default:
                               throw retry_operation("retry remove until timeout");
@@ -456,8 +441,7 @@ transactions_cleanup::remove_client_record_from_all_buckets(const std::string& u
                   }
               });
         } catch (const std::exception& e) {
-            lost_attempts_cleanup_log->error(
-              "{} Error removing client record {} from {}: {}", static_cast<void*>(this), uuid, keyspace, e.what());
+            CB_LOST_ATTEMPT_CLEANUP_LOG_ERROR("Error removing client record {} from {}: {}", uuid, keyspace, e.what());
         }
     }
 }
@@ -465,7 +449,7 @@ transactions_cleanup::remove_client_record_from_all_buckets(const std::string& u
 const atr_cleanup_stats
 transactions_cleanup::force_cleanup_atr(const core::document_id& atr_id, std::vector<transactions_cleanup_attempt>& results)
 {
-    lost_attempts_cleanup_log->trace("{} starting force_cleanup_atr: atr_id {}", static_cast<void*>(this), atr_id);
+    CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE("starting force_cleanup_atr: atr_id {}", atr_id);
     return handle_atr_cleanup(atr_id, &results);
 }
 
@@ -473,11 +457,11 @@ void
 transactions_cleanup::force_cleanup_entry(atr_cleanup_entry& entry, transactions_cleanup_attempt& attempt)
 {
     try {
-        entry.clean(attempt_cleanup_log, &attempt);
+        entry.clean(&attempt);
         attempt.success(true);
 
     } catch (const std::runtime_error& e) {
-        attempt_cleanup_log->error("error attempting to clean {}: {}", entry, e.what());
+        CB_ATTEMPT_CLEANUP_LOG_ERROR("error attempting to clean {}: {}", entry, e.what());
         attempt.success(false);
     }
 }
@@ -485,16 +469,16 @@ transactions_cleanup::force_cleanup_entry(atr_cleanup_entry& entry, transactions
 void
 transactions_cleanup::force_cleanup_attempts(std::vector<transactions_cleanup_attempt>& results)
 {
-    attempt_cleanup_log->trace("starting force_cleanup_attempts");
+    CB_ATTEMPT_CLEANUP_LOG_TRACE("starting force_cleanup_attempts");
     while (atr_queue_.size() > 0) {
         auto entry = atr_queue_.pop(false);
         if (!entry) {
-            attempt_cleanup_log->error("pop failed to return entry, but queue size {}", atr_queue_.size());
+            CB_ATTEMPT_CLEANUP_LOG_ERROR("pop failed to return entry, but queue size {}", atr_queue_.size());
             return;
         }
         results.emplace_back(*entry);
         try {
-            entry->clean(attempt_cleanup_log, &results.back());
+            entry->clean(&results.back());
             results.back().success(true);
         } catch (std::runtime_error&) {
             results.back().success(false);
@@ -506,27 +490,27 @@ void
 transactions_cleanup::attempts_loop()
 {
     try {
-        attempt_cleanup_log->debug("cleanup attempts loop starting...");
+        CB_ATTEMPT_CLEANUP_LOG_DEBUG("cleanup attempts loop starting...");
         while (interruptable_wait(cleanup_loop_delay_)) {
             while (auto entry = atr_queue_.pop()) {
-                if (!running_.load()) {
-                    attempt_cleanup_log->debug("loop stopping - {} entries on queue", atr_queue_.size());
+                if (!is_running()) {
+                    CB_ATTEMPT_CLEANUP_LOG_DEBUG("loop stopping - {} entries on queue", atr_queue_.size());
                     return;
                 }
                 if (entry) {
-                    attempt_cleanup_log->trace("beginning cleanup on {}", *entry);
+                    CB_ATTEMPT_CLEANUP_LOG_TRACE("beginning cleanup on {}", *entry);
                     try {
-                        entry->clean(attempt_cleanup_log);
+                        entry->clean();
                     } catch (...) {
                         // catch everything as we don't want to raise out of this thread
-                        attempt_cleanup_log->info("got error cleaning {}, leaving for lost txn cleanup", entry.value());
+                        CB_ATTEMPT_CLEANUP_LOG_DEBUG("got error cleaning {}, leaving for lost txn cleanup", entry.value());
                     }
                 }
             }
         }
-        attempt_cleanup_log->info("stopping - {} entries on queue", atr_queue_.size());
+        CB_ATTEMPT_CLEANUP_LOG_DEBUG("stopping - {} entries on queue", atr_queue_.size());
     } catch (const std::runtime_error& e) {
-        attempt_cleanup_log->error("got error \"{}\" in attempts_loop", e.what());
+        CB_ATTEMPT_CLEANUP_LOG_ERROR("got error \"{}\" in attempts_loop", e.what());
     }
 }
 
@@ -538,14 +522,14 @@ transactions_cleanup::add_attempt(attempt_context& ctx)
         case attempt_state::NOT_STARTED:
         case attempt_state::COMPLETED:
         case attempt_state::ROLLED_BACK:
-            attempt_cleanup_log->trace("attempt in state {}, not adding to cleanup", attempt_state_name(ctx_impl.state()));
+            CB_ATTEMPT_CLEANUP_LOG_TRACE("attempt in state {}, not adding to cleanup", attempt_state_name(ctx_impl.state()));
             return;
         default:
             if (config_.cleanup_config.cleanup_client_attempts) {
-                attempt_cleanup_log->debug("adding attempt {} to cleanup queue", ctx_impl.id());
+                CB_ATTEMPT_CLEANUP_LOG_DEBUG("adding attempt {} to cleanup queue", ctx_impl.id());
                 atr_queue_.push(ctx);
             } else {
-                attempt_cleanup_log->trace("not cleaning client attempts, ignoring {}", ctx_impl.id());
+                CB_ATTEMPT_CLEANUP_LOG_TRACE("not cleaning client attempts, ignoring {}", ctx_impl.id());
             }
     }
 }
@@ -564,7 +548,7 @@ transactions_cleanup::add_collection(couchbase::transactions::transaction_keyspa
             lost_attempt_cleanup_workers_.emplace_back([this, keyspace = collections_.back()]() { this->clean_collection(keyspace); });
         }
         lock.unlock();
-        lost_attempts_cleanup_log->info("added {} to lost transaction cleanup", keyspace);
+        CB_ATTEMPT_CLEANUP_LOG_DEBUG("added {} to lost transaction cleanup", keyspace);
     }
 }
 
@@ -578,18 +562,16 @@ transactions_cleanup::close()
     }
     if (cleanup_thr_.joinable()) {
         cleanup_thr_.join();
-        attempt_cleanup_log->info("cleanup attempt thread closed");
+        CB_ATTEMPT_CLEANUP_LOG_DEBUG("cleanup attempt thread closed");
     }
     for (auto& t : lost_attempt_cleanup_workers_) {
-        lost_attempts_cleanup_log->info("shutting down all lost attempt threads...");
+        CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("shutting down all lost attempt threads...");
         if (t.joinable()) {
             t.join();
         }
     }
-    lost_attempts_cleanup_log->info("all lost attempt cleanup threads closed");
-    if (true) {
-        remove_client_record_from_all_buckets(client_uuid_);
-    }
+    CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("all lost attempt cleanup threads closed");
+    remove_client_record_from_all_buckets(client_uuid_);
 }
 
 transactions_cleanup::~transactions_cleanup()

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

@@ -98,11 +98,11 @@ class waitable_op_list
         in_flight_--;
         if (mode_.mode == attempt_mode::modes::KV) {
             // wait until all in_flight ops are done
-            txn_log->trace("set_query_mode: waiting for in_flight ops to go to 0...");
+            CB_TXN_LOG_TRACE("set_query_mode: waiting for in_flight ops to go to 0...");
             cv_in_flight_.wait(lock, [this]() { return (0 == in_flight_); });
             // ok, now no outstanding ops(apart from the query that called this), and I have the lock, so...
             if (mode_.mode == attempt_mode::modes::KV) {
-                txn_log->trace("set_query_mode: in_flight ops = 0, we were kv, setting mode to query");
+                CB_TXN_LOG_TRACE("set_query_mode: in_flight ops = 0, we were kv, setting mode to query");
                 // still kv, so now (while blocking) set the mode
                 mode_.mode = attempt_mode::modes::QUERY;
                 // ok to unlock now, as any racing set_query_mode will wait for
@@ -117,10 +117,11 @@ class waitable_op_list
         }
         // you make it here, and someone else is currently setting the node (a byproduct of
         // calling the callback).  So wait for that.
-        txn_log->trace("set_query_mode: mode already query, waiting for node to be set...");
+        CB_TXN_LOG_TRACE("set_query_mode: mode already query, waiting for node to be set...");
         cv_query_.wait(lock, [this]() { return !mode_.query_node.empty(); });
+        cv_in_flight_.wait(lock, [this]() { return 0 == in_flight_; });
         in_flight_++;
-        txn_log->trace("set_query_mode: node set, continuing...");
+        CB_TXN_LOG_TRACE("set_query_mode: node set, continuing...");
         lock.unlock();
         cb();
     }
@@ -145,7 +146,7 @@ class waitable_op_list
     {
         std::lock_guard<std::mutex> lock(mutex_);
         in_flight_--;
-        txn_log->trace("in_flight decremented to {}", in_flight_);
+        CB_TXN_LOG_TRACE("in_flight decremented to {}", in_flight_);
         assert(in_flight_ >= 0);
         if (0 == in_flight_) {
             cv_in_flight_.notify_all();
@@ -161,7 +162,7 @@ class waitable_op_list
             if (val > 0) {
                 in_flight_ += val;
             }
-            txn_log->trace("op count changed by {} to {}, {} in_flight", val, count_, in_flight_);
+            CB_TXN_LOG_TRACE("op count changed by {} to {}, {} in_flight", val, count_, in_flight_);
             assert(count_ >= 0);
             assert(in_flight_ >= 0);
             if (0 == count_) {
@@ -171,7 +172,7 @@ class waitable_op_list
                 cv_in_flight_.notify_all();
             }
         } else {
-            txn_log->error("operation attempted after commit/rollback");
+            CB_TXN_LOG_ERROR("operation attempted after commit/rollback");
             throw async_operation_conflict("Operation attempted after commit or rollback");
         }
     }