couchbase 3.5.2 → 3.5.3

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

@@ -26,10 +26,14 @@
 #include "internal/transactions_cleanup.hxx"
 #include "internal/utils.hxx"
 
+#include "core/operations.hxx"
+#include "core/utils/byteswap.hxx"
+
 #include <couchbase/fmt/transaction_keyspace.hxx>
 
 #include <functional>
 #include <memory>
+#include <utility>
 
 namespace couchbase::core::transactions
 {
@@ -44,26 +48,16 @@ transactions_cleanup_attempt::transactions_cleanup_attempt(const atr_cleanup_ent
 
 transactions_cleanup::transactions_cleanup(
   core::cluster cluster,
-  const couchbase::transactions::transactions_config::built& config)
+  couchbase::transactions::transactions_config::built config)
   : cluster_(std::move(cluster))
-  , config_(config)
+  , config_(std::move(config))
   , client_uuid_(uid_generator::next())
 {
   start();
 }
 
-static auto
-byteswap64(std::uint64_t val) -> std::uint64_t
+namespace
 {
-  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;
-}
-
 /**
  * ${Mutation.CAS} is written by kvengine with
  * 'macroToString(htonll(info.cas))'.  Discussed this with KV team and, though
@@ -77,38 +71,32 @@ byteswap64(std::uint64_t val) -> std::uint64_t
  * Want:        0x155CD21DA7580000   (1539336197457313792 in base10, an epoch
  * time in millionths of a second)
  */
-static auto
+auto
 parse_mutation_cas(const std::string& cas) -> std::uint64_t
 {
   if (cas.empty()) {
     return 0;
   }
-  return byteswap64(stoull(cas, nullptr, 16)) / 1000000;
+  return core::utils::byte_swap(static_cast<std::uint64_t>(std::stoull(cas, nullptr, 16))) /
+         1000000;
 }
 
-static const std::string CLIENT_RECORD_DOC_ID = "_txn:client-record";
-static const std::string FIELD_RECORDS = "records";
-static const std::string FIELD_CLIENTS_ONLY = "clients";
-static const std::string FIELD_CLIENTS = FIELD_RECORDS + "." + FIELD_CLIENTS_ONLY;
-static const std::string FIELD_HEARTBEAT = "heartbeat_ms";
-static const std::string FIELD_EXPIRES = "expires_ms";
-static const std::string FIELD_OVERRIDE = "override";
-static const std::string FIELD_OVERRIDE_EXPIRES = "expires";
-static const std::string FIELD_OVERRIDE_ENABLED = "enabled";
-static const std::string FIELD_NUM_ATRS = "num_atrs";
+// TODO(CXXCBC-549)
+const std::string CLIENT_RECORD_DOC_ID = "_txn:client-record"; // NOLINT(cert-err58-cpp)
+} // namespace
 
-#define SAFETY_MARGIN_EXPIRY_MS 2000
+constexpr auto SAFETY_MARGIN_EXPIRY_MS = 2000;
 
 template<class R, class P>
 auto
-transactions_cleanup::interruptable_wait(std::chrono::duration<R, P> delay) -> bool
+transactions_cleanup::interruptable_wait(std::chrono::duration<R, P> time) -> bool
 {
   // wait for specified time, _or_ until the condition variable changes
   std::unique_lock<std::mutex> lock(mutex_);
   if (!running_) {
     return false;
   }
-  cv_.wait_for(lock, delay, [&]() {
+  cv_.wait_for(lock, time, [&]() {
     return !running_;
   });
   return running_;
@@ -121,7 +109,7 @@ transactions_cleanup::clean_collection(
   // first make sure the collection is in the list
   while (is_running()) {
     {
-      std::lock_guard<std::mutex> lock(mutex_);
+      const std::lock_guard<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);
@@ -135,9 +123,8 @@ transactions_cleanup::clean_collection(
 
       auto all_atrs = atr_ids::all();
 
-      std::chrono::microseconds cleanup_window =
-        std::chrono::duration_cast<std::chrono::microseconds>(
-          config_.cleanup_config.cleanup_window);
+      const auto cleanup_window = std::chrono::duration_cast<std::chrono::microseconds>(
+        config_.cleanup_config.cleanup_window);
       auto start = std::chrono::steady_clock::now();
       CB_LOST_ATTEMPT_CLEANUP_LOG_INFO(
         "{} active clients (including this one), {} ATRs to check in {}ms",
@@ -150,12 +137,11 @@ transactions_cleanup::clean_collection(
         auto atrs_left_for_this_client =
           std::distance(it, all_atrs.end()) /
           std::max<decltype(it)::difference_type>(1, details.num_active_clients);
-        auto now = std::chrono::steady_clock::now();
-        std::chrono::microseconds elapsed_in_cleanup_window =
+        const auto now = std::chrono::steady_clock::now();
+        const auto elapsed_in_cleanup_window =
           std::chrono::duration_cast<std::chrono::microseconds>(now - start);
-        std::chrono::microseconds remaining_in_cleanup_window =
-          cleanup_window - elapsed_in_cleanup_window;
-        std::chrono::microseconds budget_for_this_atr = std::chrono::microseconds(
+        const auto remaining_in_cleanup_window = cleanup_window - elapsed_in_cleanup_window;
+        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
@@ -172,10 +158,9 @@ transactions_cleanup::clean_collection(
             "cleanup of atr {} failed with {}, moving on", atr_id, e.what());
         }
 
-        auto atr_end = std::chrono::steady_clock::now();
-        std::chrono::microseconds atr_used =
-          std::chrono::duration_cast<std::chrono::microseconds>(atr_end - now);
-        std::chrono::microseconds atr_left = budget_for_this_atr - atr_used;
+        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
@@ -208,7 +193,7 @@ transactions_cleanup::clean_collection(
 auto
 transactions_cleanup::handle_atr_cleanup(const core::document_id& atr_id,
                                          std::vector<transactions_cleanup_attempt>* results)
-  -> const atr_cleanup_stats
+  -> atr_cleanup_stats
 {
   atr_cleanup_stats stats;
   auto atr = active_transaction_record::get_atr(cluster_, atr_id);
@@ -253,7 +238,7 @@ transactions_cleanup::create_client_record(
     req.store_semantics = couchbase::store_semantics::insert;
     req.specs =
       couchbase::mutate_in_specs{
-        couchbase::mutate_in_specs::insert(FIELD_CLIENTS, tao::json::empty_object)
+        couchbase::mutate_in_specs::insert("records.clients", tao::json::empty_object)
           .xattr()
           .create_path(),
         // subdoc::opcode::set_doc used in replace w/ empty path
@@ -291,7 +276,7 @@ transactions_cleanup::create_client_record(
 auto
 transactions_cleanup::get_active_clients(
   const couchbase::transactions::transaction_keyspace& keyspace,
-  const std::string& uuid) -> const client_record_details
+  const std::string& uuid) -> client_record_details
 {
   client_record_details details;
   // Write our client record, return details.
@@ -301,7 +286,7 @@ transactions_cleanup::get_active_clients(
     core::operations::lookup_in_request req{ id };
     req.specs =
       lookup_in_specs{
-        lookup_in_specs::get(FIELD_RECORDS).xattr(),
+        lookup_in_specs::get("records").xattr(),
         lookup_in_specs::get(subdoc::lookup_in_macro::vbucket).xattr(),
       }
         .specs();
@@ -327,21 +312,22 @@ transactions_cleanup::get_active_clients(
       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) {
+        if (key == "override") {
           for (const auto& [over_ride, param] : value.get_object()) {
-            if (over_ride == FIELD_OVERRIDE_ENABLED) {
+            if (over_ride == "enabled") {
               details.override_enabled = param.get_boolean();
-            } else if (over_ride == FIELD_OVERRIDE_EXPIRES) {
+            } else if (over_ride == "expires") {
               details.override_expires = param.as<std::uint64_t>();
             }
           }
-        } else if (key == FIELD_CLIENTS_ONLY) {
+        } else if (key == "clients") {
           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>();
+            const std::uint64_t heartbeat_ms =
+              parse_mutation_cas(cl.at("heartbeat_ms").get_string());
+            auto expires_ms = cl.at("expires_ms").as<std::uint64_t>();
             auto expired_period =
               static_cast<std::int64_t>(now_ms) - static_cast<std::int64_t>(heartbeat_ms);
-            bool has_expired =
+            const 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);
@@ -378,16 +364,16 @@ transactions_cleanup::get_active_clients(
     // 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,
+      couchbase::mutate_in_specs::upsert(fmt::format("records.clients.{}.heartbeat_ms", uuid),
                                          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 +
+      couchbase::mutate_in_specs::upsert(fmt::format("records.clients.{}.expires_ms", uuid),
+                                         (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,
+      couchbase::mutate_in_specs::upsert(fmt::format("records.clients.{}.num_atrs", uuid),
                                          atr_ids::all().size())
         .xattr()
         .create_path(),
@@ -398,9 +384,9 @@ transactions_cleanup::get_active_clients(
       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());
+      mut_specs.push_back(couchbase::mutate_in_specs::remove(
+                            fmt::format("records.clients.{}", details.expired_client_ids[idx]))
+                            .xattr());
     }
     mutate_req.specs = mut_specs.specs();
     ec = wait_for_hook([this, bucket = keyspace.bucket](auto handler) mutable {
@@ -454,13 +440,13 @@ transactions_cleanup::remove_client_record_from_all_buckets(const std::string& u
             if (ec) {
               throw client_error(*ec, "client_record_before_remove_client hook raised error");
             }
-            document_id id{
+            const document_id id{
               keyspace.bucket, keyspace.scope, keyspace.collection, CLIENT_RECORD_DOC_ID
             };
             core::operations::mutate_in_request req{ id };
             req.specs =
               couchbase::mutate_in_specs{
-                couchbase::mutate_in_specs::remove(FIELD_CLIENTS + "." + uuid).xattr(),
+                couchbase::mutate_in_specs::remove(fmt::format("records.clients.{}", uuid)).xattr(),
               }
                 .specs();
             wrap_durable_request(req, config_);
@@ -497,7 +483,7 @@ transactions_cleanup::remove_client_record_from_all_buckets(const std::string& u
 auto
 transactions_cleanup::force_cleanup_atr(const core::document_id& atr_id,
                                         std::vector<transactions_cleanup_attempt>& results)
-  -> const atr_cleanup_stats
+  -> atr_cleanup_stats
 {
   CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE("starting force_cleanup_atr: atr_id {}", atr_id);
   return handle_atr_cleanup(atr_id, &results);
@@ -549,7 +535,9 @@ transactions_cleanup::attempts_loop()
           CB_ATTEMPT_CLEANUP_LOG_DEBUG("loop stopping - {} entries on queue", atr_queue_.size());
           return;
         }
-        if (entry) {
+        // FIXME(SA): for some reason cppcheck thinks that entry here will
+        // be always true, while pop() operation still might return empty optional
+        if (entry) { // cppcheck-suppress knownConditionTrueFalse
           CB_ATTEMPT_CLEANUP_LOG_TRACE("beginning cleanup on {}", *entry);
           try {
             entry->clean();
@@ -568,9 +556,10 @@ transactions_cleanup::attempts_loop()
 }
 
 void
-transactions_cleanup::add_attempt(std::shared_ptr<attempt_context> ctx)
+transactions_cleanup::add_attempt(const std::shared_ptr<attempt_context>& ctx)
 {
   auto ctx_impl = std::dynamic_pointer_cast<attempt_context_impl>(ctx);
+  Expects(ctx_impl != nullptr);
   switch (ctx_impl->state()) {
     case attempt_state::NOT_STARTED:
     case attempt_state::COMPLETED:
@@ -589,7 +578,7 @@ transactions_cleanup::add_attempt(std::shared_ptr<attempt_context> ctx)
 }
 
 void
-transactions_cleanup::add_collection(couchbase::transactions::transaction_keyspace keyspace)
+transactions_cleanup::add_collection(const couchbase::transactions::transaction_keyspace& keyspace)
 {
 
   if (keyspace.valid() && config_.cleanup_config.cleanup_lost_attempts) {
@@ -597,7 +586,7 @@ transactions_cleanup::add_collection(couchbase::transactions::transaction_keyspa
 
     auto it = std::find(collections_.begin(), collections_.end(), keyspace);
     if (it == collections_.end()) {
-      collections_.emplace_back(std::move(keyspace));
+      collections_.emplace_back(keyspace);
       // start cleaning right away
       lost_attempt_cleanup_workers_.emplace_back([this, keyspace = collections_.back()]() {
         this->clean_collection(keyspace);
@@ -614,7 +603,9 @@ transactions_cleanup::start()
   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));
+    cleanup_thr_ = std::thread([this] {
+      attempts_loop();
+    });
   }
   if (config_.metadata_collection) {
     add_collection({ config_.metadata_collection->bucket,
@@ -630,7 +621,7 @@ void
 transactions_cleanup::stop()
 {
   {
-    std::unique_lock<std::mutex> lock(mutex_);
+    const std::unique_lock<std::mutex> lock(mutex_);
     running_ = false;
     cv_.notify_all();
   }

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

@@ -25,9 +25,7 @@ namespace couchbase::transactions
 {
 
 transactions_config::transactions_config()
-  : level_(couchbase::durability_level::majority)
-  , timeout_(std::chrono::seconds(15))
-  , attempt_context_hooks_(new core::transactions::attempt_context_testing_hooks())
+  : attempt_context_hooks_(new core::transactions::attempt_context_testing_hooks())
   , cleanup_hooks_(new core::transactions::cleanup_testing_hooks())
 {
 }

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

@@ -18,10 +18,12 @@
 
 #include "uid_generator.hxx"
 
-// TODO: Remove this, and just use client directly
+// TODO(SA): Remove this, and just use client directly
 
 auto
 couchbase::core::transactions::uid_generator::next() -> std::string
 {
+  // TODO(CXXCBC-549)
+  // NOLINTNEXTLINE(clang-analyzer-security.insecureAPI.rand)
   return core::uuid::to_string(core::uuid::random());
 }

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

@@ -49,12 +49,12 @@ jsonify(const tao::json::value& obj) -> std::string
 auto
 now_ns_from_vbucket(const tao::json::value& vbucket) -> std::uint64_t
 {
-  std::string now_str = vbucket.at("HLC").at("now").get_string();
+  const std::string now_str = vbucket.at("HLC").at("now").get_string();
   return stoull(now_str, nullptr, 10) * 1000000000;
 }
 
 void
-wrap_collection_call(result& res, std::function<void(result&)> call)
+wrap_collection_call(result& res, const std::function<void(result&)>& call)
 {
   call(res);
   if (!res.is_success()) {
@@ -99,8 +99,8 @@ wrap_operation_future(std::future<result>& fut, bool ignore_subdoc_errors) -> re
 }
 
 auto
-wait_for_hook(std::function<void(utils::movable_function<void(std::optional<error_class>)>)> hook)
-  -> std::optional<error_class>
+wait_for_hook(const std::function<void(utils::movable_function<void(std::optional<error_class>)>)>&
+                hook) -> std::optional<error_class>
 {
   auto hook_barrier = std::make_shared<std::promise<std::optional<error_class>>>();
   auto hook_future = hook_barrier->get_future();
@@ -122,17 +122,17 @@ auto
 error_class_from_response_extras(const core::operations::mutate_in_response& resp)
   -> std::optional<error_class>
 {
-  if (!resp.ctx.first_error_index()) {
-    return {};
-  }
-  auto status = resp.fields.at(*resp.ctx.first_error_index()).status;
-  if (status == key_value_status_code::subdoc_path_not_found) {
-    return FAIL_PATH_NOT_FOUND;
-  }
-  if (status == key_value_status_code::subdoc_path_exists) {
-    return FAIL_PATH_ALREADY_EXISTS;
+  if (const auto& first_error_index = resp.ctx.first_error_index(); first_error_index.has_value()) {
+    auto status = resp.fields.at(first_error_index.value()).status;
+    if (status == key_value_status_code::subdoc_path_not_found) {
+      return FAIL_PATH_NOT_FOUND;
+    }
+    if (status == key_value_status_code::subdoc_path_exists) {
+      return FAIL_PATH_ALREADY_EXISTS;
+    }
+    return FAIL_OTHER;
   }
-  return FAIL_OTHER;
+  return {};
 }
 
 auto

data/ext/couchbase/core/transactions.hxx

@@ -183,7 +183,7 @@ public:
            logic&& code) -> couchbase::transactions::transaction_result;
 
   auto run(::couchbase::transactions::txn_logic&& code,
-           const couchbase::transactions::transaction_options& cfg)
+           const couchbase::transactions::transaction_options& config)
     -> std::pair<couchbase::error, couchbase::transactions::transaction_result> override;
 
   /**
@@ -206,7 +206,7 @@ public:
 
   void run(couchbase::transactions::async_txn_logic&& code,
            couchbase::transactions::async_txn_complete_logic&& complete_cb,
-           const couchbase::transactions::transaction_options& cfg) override;
+           const couchbase::transactions::transaction_options& config) override;
   /**
    * @internal
    * called internally - will likely move
@@ -276,8 +276,7 @@ public:
   /**
    * @internal
    */
-  transactions(core::cluster cluster,
-               const couchbase::transactions::transactions_config::built& config);
+  transactions(core::cluster cluster, couchbase::transactions::transactions_config::built config);
   transactions(core::cluster cluster, const couchbase::transactions::transactions_config& config);
 
   ~transactions() override;

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

@@ -15,6 +15,8 @@
  *   limitations under the License.
  */
 
+#include <couchbase/build_config.hxx>
+
 #include "connection_string.hxx"
 #include "core/logger/logger.hxx"
 #include "core/meta/version.hxx"
@@ -105,7 +107,7 @@ struct action<param> {
   {
     const auto& pair = in.string();
     auto eq = pair.find('=');
-    std::string key = pair.substr(0, eq);
+    const std::string key = pair.substr(0, eq);
     cs.params[key] = (eq == std::string::npos) ? "" : pair.substr(eq + 1);
   }
 };
@@ -205,6 +207,8 @@ struct action<bucket_name> {
 };
 } // namespace priv
 
+namespace
+{
 void
 parse_option(std::string& receiver,
              const std::string& /* name */,
@@ -320,7 +324,7 @@ parse_option(std::chrono::milliseconds& receiver,
   }
 }
 
-static void
+void
 extract_options(connection_string& connstr)
 {
   connstr.options.enable_tls = connstr.tls;
@@ -425,6 +429,13 @@ extract_options(connection_string& connstr)
        * The period of time allocated to complete bootstrap
        */
       parse_option(connstr.options.bootstrap_timeout, name, value, connstr.warnings);
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    } else if (name == "dispatch_timeout") {
+      /**
+       * The period of time allocated to complete HTTP session bootstrap
+       */
+      parse_option(connstr.options.dispatch_timeout, name, value, connstr.warnings);
+#endif
     } else if (name == "resolve_timeout") {
       /**
        * The period of time to resolve DNS name of the node to IP address
@@ -501,6 +512,7 @@ extract_options(connection_string& connstr)
     }
   }
 }
+} // namespace
 
 auto
 parse_connection_string(const std::string& input, cluster_options options) -> connection_string

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

@@ -19,10 +19,12 @@
 
 namespace couchbase::core::utils
 {
+namespace
+{
 /**
  * leading_int consumes the leading [0-9]* from s.
  */
-static auto
+auto
 leading_int(std::string& s, std::int64_t& v) -> bool
 {
   v = 0;
@@ -34,11 +36,11 @@ leading_int(std::string& s, std::int64_t& v) -> bool
       break;
     }
 
-    if (v > std::int64_t((1LLU << 63U) - 1LLU) / 10) {
+    if (v > static_cast<std::int64_t>((1LLU << 63U) - 1LLU) / 10) {
       return false;
     }
 
-    v = v * 10 + std::int64_t(c) - '0';
+    v = v * 10 + static_cast<std::int64_t>(c) - '0';
 
     if (v < 0) {
       return false;
@@ -54,8 +56,7 @@ leading_int(std::string& s, std::int64_t& v) -> bool
  * It is used only for fractions, so does not return an error on overflow,
  * it just stops accumulating precision.
  */
-
-static void
+void
 leading_fraction(std::string& s, std::int64_t& x, std::uint32_t& scale)
 {
   std::size_t i = 0;
@@ -74,13 +75,13 @@ leading_fraction(std::string& s, std::int64_t& x, std::uint32_t& scale)
       continue;
     }
 
-    if (x > std::int64_t((1LLU << 63LLU) - 1LLU) / 10) {
+    if (x > static_cast<std::int64_t>((1LLU << 63LLU) - 1LLU) / 10) {
       // It's possible for overflow to give a positive number, so take care.
       overflow = true;
       continue;
     }
 
-    auto y = x * 10 + std::int64_t(c) - '0';
+    auto y = (x * 10) + static_cast<std::int64_t>(c) - '0';
     if (y < 0) {
       overflow = true;
       continue;
@@ -92,6 +93,7 @@ leading_fraction(std::string& s, std::int64_t& x, std::uint32_t& scale)
 
   s = s.substr(i);
 }
+} // namespace
 
 auto
 parse_duration(const std::string& text) -> std::chrono::nanoseconds
@@ -125,7 +127,7 @@ parse_duration(const std::string& text) -> std::chrono::nanoseconds
 
   while (!s.empty()) {
     // The next character must be [0-9.]
-    if (!(s[0] == '.' || ('0' <= s[0] && s[0] <= '9'))) {
+    if (s[0] != '.' && ('0' > s[0] || s[0] > '9')) {
       throw duration_parse_error("invalid duration: " + text);
     }
 
@@ -137,7 +139,7 @@ parse_duration(const std::string& text) -> std::chrono::nanoseconds
       throw duration_parse_error("invalid duration (leading_int overflow): " + text);
     }
 
-    bool pre = pl != s.size(); // whether we consumed anything before a period
+    const bool pre = pl != s.size(); // whether we consumed anything before a period
 
     std::int64_t f{ 0 };      // integer after decimal point
     std::uint32_t scale{ 1 }; // value = v + f/scale

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

@@ -112,7 +112,7 @@ private:
     buffer_.insert(buffer_.end(), begin, begin + data.size());
   }
 
-  inline void escape(const std::string_view s)
+  void escape(const std::string_view s)
   {
     static std::array h{
       std::byte{ '0' }, std::byte{ '1' }, std::byte{ '2' }, std::byte{ '3' },
@@ -156,8 +156,11 @@ private:
               std::byte{ 'u' },
               std::byte{ '0' },
               std::byte{ '0' },
+              // TODO(CXXCBC-549)
+              // NOLINTBEGIN(cppcoreguidelines-pro-bounds-constant-array-index)
               std::byte{ h[(c & 0xf0) >> 4] },
               std::byte{ h[c & 0x0f] },
+              // NOLINTEND(cppcoreguidelines-pro-bounds-constant-array-index)
             });
         }
       } else {
@@ -207,6 +210,8 @@ public:
   void number(const std::int64_t v)
   {
     next();
+    // TODO(CXXCBC-549)
+    // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
     char b[24]{};
     const char* s = tao::json::itoa::i64toa(v, b);
     write({ b, static_cast<std::size_t>(s - b) });
@@ -215,6 +220,8 @@ public:
   void number(const std::uint64_t v)
   {
     next();
+    // TODO(CXXCBC-549)
+    // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
     char b[24]{};
     const char* s = tao::json::itoa::u64toa(v, b);
     write({ b, static_cast<std::size_t>(s - b) });
@@ -227,7 +234,9 @@ public:
       // if this throws, consider using non_finite_to_* transformers
       throw std::runtime_error("non-finite double value invalid for JSON string representation");
     }
-    char b[28];
+    // TODO(CXXCBC-549)
+    // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+    char b[28]{};
     const auto s = tao::json::ryu::d2s_finite(v, b);
     write({ b, s });
   }
@@ -240,8 +249,9 @@ public:
     buffer_.emplace_back(std::byte{ '"' });
   }
 
-  void binary(
-    const tao::binary_view /*unused*/) // NOLINT(readability-convert-member-functions-to-static)
+  // TODO(CXXCBC-549)
+  // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
+  void binary(const tao::binary_view /*unused*/)
   {
     // if this throws, consider using binary_to_* transformers
     throw std::runtime_error("binary data invalid for JSON string representation");

data/ext/couchbase/core/utils/json.hxx

@@ -19,7 +19,7 @@
 
 #include "core/json_string.hxx"
 
-#include <tao/json/value.hpp>
+#include <tao/json/forward.hpp>
 
 namespace couchbase::core::utils::json
 {