couchbase 4.4.1 → 4.4.3

package/deps/couchbase-cxx-client/core/operations/management/search_index_get_documents_count.cxx

@@ -18,6 +18,7 @@
 #include "search_index_get_documents_count.hxx"
 
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -33,8 +34,8 @@ search_index_get_documents_count_request::encode_to(encoded_request_type& encode
   encoded.method = "GET";
   if (bucket_name.has_value() && scope_name.has_value()) {
     encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}/count",
-                               bucket_name.value(),
-                               scope_name.value(),
+                               utils::string_codec::v2::path_escape(bucket_name.value()),
+                               utils::string_codec::v2::path_escape(scope_name.value()),
                                index_name);
   } else {
     encoded.path = fmt::format("/api/index/{}/count", index_name);

package/deps/couchbase-cxx-client/core/operations/management/search_index_upsert.cxx

@@ -19,6 +19,7 @@
 
 #include "core/management/search_index_json.hxx"
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -37,8 +38,10 @@ search_index_upsert_request::encode_to(encoded_request_type& encoded,
   encoded.headers["cache-control"] = "no-cache";
   encoded.headers["content-type"] = "application/json";
   if (bucket_name.has_value() && scope_name.has_value()) {
-    encoded.path = fmt::format(
-      "/api/bucket/{}/scope/{}/index/{}", bucket_name.value(), scope_name.value(), index.name);
+    encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}",
+                               utils::string_codec::v2::path_escape(bucket_name.value()),
+                               utils::string_codec::v2::path_escape(scope_name.value()),
+                               index.name);
   } else {
     encoded.path = fmt::format("/api/index/{}", index.name);
   }

package/deps/couchbase-cxx-client/core/operations/management/view_index_drop.cxx

@@ -17,6 +17,7 @@
 
 #include "view_index_drop.hxx"
 
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -30,7 +31,7 @@ view_index_drop_request::encode_to(encoded_request_type& encoded,
 {
   encoded.method = "DELETE";
   encoded.path = fmt::format("/{}/_design/{}{}",
-                             bucket_name,
+                             utils::string_codec::v2::path_escape(bucket_name),
                              ns == design_document_namespace::development ? "dev_" : "",
                              document_name);
   return {};

package/deps/couchbase-cxx-client/core/operations/management/view_index_get.cxx

@@ -18,6 +18,7 @@
 #include "view_index_get.hxx"
 
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -31,7 +32,7 @@ view_index_get_request::encode_to(encoded_request_type& encoded,
 {
   encoded.method = "GET";
   encoded.path = fmt::format("/{}/_design/{}{}",
-                             bucket_name,
+                             utils::string_codec::v2::path_escape(bucket_name),
                              ns == design_document_namespace::development ? "dev_" : "",
                              document_name);
   return {};

package/deps/couchbase-cxx-client/core/operations/management/view_index_get_all.cxx

@@ -18,6 +18,7 @@
 #include "view_index_get_all.hxx"
 
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -30,7 +31,8 @@ view_index_get_all_request::encode_to(encoded_request_type& encoded,
                                       http_context& /* context */) const -> std::error_code
 {
   encoded.method = "GET";
-  encoded.path = fmt::format("/pools/default/buckets/{}/ddocs", bucket_name);
+  encoded.path = fmt::format("/pools/default/buckets/{}/ddocs",
+                             utils::string_codec::v2::path_escape(bucket_name));
   return {};
 }
 

package/deps/couchbase-cxx-client/core/operations/management/view_index_upsert.cxx

@@ -18,6 +18,7 @@
 #include "view_index_upsert.hxx"
 
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
@@ -45,7 +46,7 @@ view_index_upsert_request::encode_to(encoded_request_type& encoded,
   encoded.headers["content-type"] = "application/json";
   encoded.method = "PUT";
   encoded.path = fmt::format("/{}/_design/{}{}",
-                             bucket_name,
+                             utils::string_codec::v2::path_escape(bucket_name),
                              document.ns == design_document_namespace::development ? "dev_" : "",
                              document.name);
   encoded.body = utils::json::generate(body);

package/deps/couchbase-cxx-client/core/origin.cxx

@@ -210,6 +210,24 @@ struct traits<couchbase::transactions::transactions_config::built> {
   }
 };
 
+template<>
+struct traits<couchbase::core::columnar::security_options> {
+  template<template<typename...> class Traits>
+  static void assign(tao::json::basic_value<Traits>& v,
+                     const couchbase::core::columnar::security_options& o)
+  {
+    v = {
+      { "trust_only_capella", o.trust_only_capella },
+      { "trust_only_pem_file", o.trust_only_pem_file },
+      { "trust_only_pem_string", o.trust_only_pem_string },
+      { "trust_only_platform", o.trust_only_platform },
+      { "trust_only_certificates", o.trust_only_certificates.size() },
+      // TODO(JC): add if/when we support the cipher_suites option
+      // { "cipher_suites", utils::join_strings(o.cipher_suites, ":") },
+    };
+  }
+};
+
 } // namespace tao::json
 
 namespace couchbase::core
@@ -222,45 +240,47 @@ origin::to_json() const -> std::string
       "options",
       {
         { "bootstrap_timeout", options_.bootstrap_timeout },
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-        { "dispatch_timeout", options_.dispatch_timeout },
-#endif
         { "resolve_timeout", options_.resolve_timeout },
         { "connect_timeout", options_.connect_timeout },
+        { "query_timeout", options_.query_timeout },
+        { "management_timeout", options_.management_timeout },
+        { "trust_certificate", options_.trust_certificate },
+        { "use_ip_protocol", options_.use_ip_protocol },
+        { "enable_dns_srv", options_.enable_dns_srv },
+        { "dns_config", options_.dns_config },
+        { "enable_clustermap_notification", options_.enable_clustermap_notification },
+        { "config_poll_interval", options_.config_poll_interval },
+        { "config_poll_floor", options_.config_poll_floor },
+        { "user_agent_extra", options_.user_agent_extra },
+        { "dump_configuration", options_.dump_configuration },
+        { "disable_mozilla_ca_certificates", options_.disable_mozilla_ca_certificates },
+        { "network", options_.network },
+        { "tls_verify", options_.tls_verify },
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+        { "dispatch_timeout", options_.dispatch_timeout },
+        { "security_options", options_.security_options },
+#else
         { "key_value_timeout", options_.key_value_timeout },
         { "key_value_durable_timeout", options_.key_value_durable_timeout },
         { "view_timeout", options_.view_timeout },
-        { "query_timeout", options_.query_timeout },
         { "analytics_timeout", options_.analytics_timeout },
         { "search_timeout", options_.search_timeout },
-        { "management_timeout", options_.management_timeout },
         { "enable_tls", options_.enable_tls },
-        { "trust_certificate", options_.trust_certificate },
         { "enable_mutation_tokens", options_.enable_mutation_tokens },
         { "enable_tcp_keep_alive", options_.enable_tcp_keep_alive },
-        { "use_ip_protocol", options_.use_ip_protocol },
-        { "enable_dns_srv", options_.enable_dns_srv },
-        { "dns_config", options_.dns_config },
         { "show_queries", options_.show_queries },
         { "enable_unordered_execution", options_.enable_unordered_execution },
-        { "enable_clustermap_notification", options_.enable_clustermap_notification },
         { "enable_compression", options_.enable_compression },
         { "enable_tracing", options_.enable_tracing },
         { "enable_metrics", options_.enable_metrics },
         { "tcp_keep_alive_interval", options_.tcp_keep_alive_interval },
-        { "config_poll_interval", options_.config_poll_interval },
-        { "config_poll_floor", options_.config_poll_floor },
         { "config_idle_redial_timeout", options_.config_idle_redial_timeout },
         { "max_http_connections", options_.max_http_connections },
         { "idle_http_connection_timeout", options_.idle_http_connection_timeout },
-        { "user_agent_extra", options_.user_agent_extra },
-        { "dump_configuration", options_.dump_configuration },
-        { "disable_mozilla_ca_certificates", options_.disable_mozilla_ca_certificates },
         { "metrics_options", options_.metrics_options },
-        { "network", options_.network },
-        { "tls_verify", options_.tls_verify },
         { "tracing_options", options_.tracing_options },
         { "transactions_options", options_.transactions },
+#endif
       },
     },
   };

package/deps/couchbase-cxx-client/core/platform/CMakeLists.txt

@@ -2,22 +2,3 @@ add_library(couchbase_backtrace OBJECT backtrace.c)
 target_include_directories(couchbase_backtrace PRIVATE ${PROJECT_BINARY_DIR}/generated ../..)
 target_link_libraries(couchbase_backtrace PRIVATE ${PLATFORM_LIBRARIES})
 set_target_properties(couchbase_backtrace PROPERTIES POSITION_INDEPENDENT_CODE ON)
-
-add_library(
-  couchbase_platform STATIC
-  dirutils.cc
-  random.cc
-  string_hex.cc
-  uuid.cc
-  base64.cc
-  terminate_handler.cc)
-set_target_properties(couchbase_platform PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_include_directories(couchbase_platform PRIVATE ${PROJECT_BINARY_DIR}/generated ../..)
-target_link_libraries(
-  couchbase_platform
-  PRIVATE project_options
-          project_warnings
-          couchbase_backtrace
-          fmt::fmt
-          spdlog::spdlog
-          Microsoft.GSL::GSL)

package/deps/couchbase-cxx-client/core/platform/base64.cc

@@ -34,14 +34,16 @@
 #include <string_view>
 #include <vector>
 
+namespace
+{
 /**
  * An array of the legal characters used for direct lookup
  */
-static const std::array codemap{ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
-                                 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-                                 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
-                                 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-                                 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' };
+const std::array codemap{ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+                          'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+                          'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+                          'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+                          '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' };
 
 /**
  * A method to map the code back to the value
@@ -49,8 +51,8 @@ static const std::array codemap{ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J
  * @param code the code to map
  * @return the byte value for the code character
  */
-static std::uint32_t
-code2val(const char code)
+auto
+code2val(const char code) -> std::uint32_t
 {
   if (code >= 'A' && code <= 'Z') {
     return static_cast<std::uint32_t>(code) - static_cast<std::uint32_t>('A');
@@ -70,6 +72,8 @@ code2val(const char code)
   throw std::invalid_argument("couchbase::core::base64::code2val Invalid input character");
 }
 
+// TODO(CXXCBC-549): clang-tidy-19 reports subscript with non-const index
+// NOLINTBEGIN(cppcoreguidelines-pro-bounds-constant-array-index)
 /**
  * Encode up to 3 characters to 4 output character.
  *
@@ -77,7 +81,7 @@ code2val(const char code)
  * @param d pointer to the output stream
  * @param num the number of characters from s to encode
  */
-static void
+void
 encode_rest(const std::byte* s, std::string& result, size_t num)
 {
   std::uint32_t val = 0;
@@ -109,7 +113,7 @@ encode_rest(const std::byte* s, std::string& result, size_t num)
  * @param s pointer to the input stream
  * @param d pointer to the output stream
  */
-static void
+void
 encode_triplet(const std::byte* s, std::string& str)
 {
   auto val = (static_cast<std::uint32_t>(*s) << 16U) |      //
@@ -120,6 +124,7 @@ encode_triplet(const std::byte* s, std::string& str)
   str.push_back(codemap[(val >> 6U) & 63]);
   str.push_back(codemap[val & 63]);
 }
+// NOLINTEND(cppcoreguidelines-pro-bounds-constant-array-index)
 
 /**
  * decode 4 input characters to up to two output bytes
@@ -128,8 +133,8 @@ encode_triplet(const std::byte* s, std::string& str)
  * @param d destination
  * @return the number of characters inserted
  */
-static int
-decode_quad(const char* s, std::vector<std::byte>& d)
+auto
+decode_quad(const char* s, std::vector<std::byte>& d) -> int
 {
   std::uint32_t value = code2val(s[0]) << 18U;
   value |= code2val(s[1]) << 12U;
@@ -157,11 +162,12 @@ decode_quad(const char* s, std::vector<std::byte>& d)
 
   return ret;
 }
+} // namespace
 
 namespace couchbase::core::base64
 {
-std::string
-encode(gsl::span<const std::byte> blob, bool pretty_print)
+auto
+encode(gsl::span<const std::byte> blob, bool pretty_print) -> std::string
 {
   // base64 encodes up to 3 input characters to 4 output
   // characters in the alphabet above.
@@ -176,7 +182,7 @@ encode(gsl::span<const std::byte> blob, bool pretty_print)
   if (pretty_print) {
     // In pretty-print mode we insert a newline after adding
     // 16 chunks (four characters).
-    result.reserve(chunks * 4 + chunks / 16);
+    result.reserve((chunks * 4) + (chunks / 16));
   } else {
     result.reserve(chunks * 4);
   }
@@ -204,8 +210,8 @@ encode(gsl::span<const std::byte> blob, bool pretty_print)
   return result;
 }
 
-std::vector<std::byte>
-decode(std::string_view blob)
+auto
+decode(std::string_view blob) -> std::vector<std::byte>
 {
   std::vector<std::byte> destination;
 
@@ -241,15 +247,15 @@ decode(std::string_view blob)
   return destination;
 }
 
-std::string
-decode_to_string(std::string_view blob)
+auto
+decode_to_string(std::string_view blob) -> std::string
 {
   auto decoded = decode(blob);
   return { reinterpret_cast<const char*>(decoded.data()), decoded.size() };
 }
 
-std::string
-encode(std::string_view blob, bool pretty_print)
+auto
+encode(std::string_view blob, bool pretty_print) -> std::string
 {
   return encode(gsl::as_bytes(gsl::span{ blob.data(), blob.size() }), pretty_print);
 }

package/deps/couchbase-cxx-client/core/platform/dirutils.cc

@@ -24,8 +24,10 @@
 
 namespace couchbase::core::platform
 {
-static std::string
-split(const std::string& input, bool directory)
+namespace
+{
+auto
+split(const std::string& input, bool directory) -> std::string
 {
   const std::string::size_type path = input.find_last_of("\\/");
   std::string file;
@@ -52,15 +54,16 @@ split(const std::string& input, bool directory)
   }
   return file;
 }
+} // namespace
 
-std::string
-dirname(const std::string& dir)
+auto
+dirname(const std::string& dir) -> std::string
 {
   return split(dir, true);
 }
 
-std::string
-basename(const std::string& name)
+auto
+basename(const std::string& name) -> std::string
 {
   return split(name, false);
 }
@@ -96,12 +99,16 @@ find_files_with_prefix(const std::string& dir, const std::string& name)
   return files;
 }
 #else
-std::vector<std::string>
-find_files_with_prefix(const std::string& dir, const std::string& name)
+auto
+find_files_with_prefix(const std::string& dir, const std::string& name) -> std::vector<std::string>
 {
   std::vector<std::string> files;
+  // TODO(CXXCBC-549): clang-tidy-19 reports function is not thread safe
+  // NOLINTNEXTLINE(concurrency-mt-unsafe)
   if (DIR* dp = opendir(dir.c_str()); dp != nullptr) {
     const struct dirent* de = nullptr;
+    // TODO(CXXCBC-549): clang-tidy-19 reports function is not thread safe
+    // NOLINTNEXTLINE(concurrency-mt-unsafe)
     while ((de = readdir(dp)) != nullptr) {
       if (const std::string fnm(de->d_name); fnm == "." || fnm == "..") {
         continue;
@@ -120,8 +127,8 @@ find_files_with_prefix(const std::string& dir, const std::string& name)
 }
 #endif
 
-std::vector<std::string>
-find_files_with_prefix(const std::string& name)
+auto
+find_files_with_prefix(const std::string& name) -> std::vector<std::string>
 {
   return find_files_with_prefix(dirname(name), basename(name));
 }

package/deps/couchbase-cxx-client/core/platform/random.cc

@@ -27,7 +27,9 @@
 
 #ifdef WIN32
 // We need to include windows.h _before_ wincrypt.h
+#ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
+#endif
 #include <windows.h>
 
 #include <wincrypt.h>
@@ -52,7 +54,7 @@ public:
                               "initialize random generator");
     }
 #else
-    if ((handle = open("/dev/urandom", O_RDONLY | O_CLOEXEC)) == -1) {
+    if (handle = open("/dev/urandom", O_RDONLY | O_CLOEXEC); handle == -1) {
       throw std::system_error(errno,
                               std::system_category(),
                               "RandomGeneratorProvider::Failed to "
@@ -60,6 +62,10 @@ public:
     }
 #endif
   }
+  RandomGeneratorProvider(const RandomGeneratorProvider&) = delete;
+  auto operator=(const RandomGeneratorProvider&) -> RandomGeneratorProvider& = delete;
+  RandomGeneratorProvider(RandomGeneratorProvider&&) = delete;
+  auto operator=(RandomGeneratorProvider&&) -> RandomGeneratorProvider& = delete;
 
   virtual ~RandomGeneratorProvider()
   {
@@ -70,17 +76,19 @@ public:
 #endif
   }
 
-  bool getBytes(void* dest, std::size_t size)
+  auto getBytes(void* dest, std::size_t size) -> bool
   {
     const std::lock_guard<std::mutex> lock(mutex);
 #ifdef WIN32
     return CryptGenRandom(handle, (DWORD)size, static_cast<BYTE*>(dest));
 #else
+    // TODO(CXXCBC-549)
+    // NOLINTNEXTLINE(clang-analyzer-unix.BlockInCriticalSection)
     return static_cast<std::size_t>(read(handle, dest, size)) == size;
 #endif
   }
 
-protected:
+private:
 #ifdef WIN32
   HCRYPTPROV handle{};
 #else
@@ -103,8 +111,8 @@ RandomGenerator::RandomGenerator()
   }
 }
 
-std::uint64_t
-RandomGenerator::next()
+auto
+RandomGenerator::next() -> std::uint64_t
 {
   std::uint64_t ret = 0;
   if (getBytes(&ret, sizeof(ret))) {
@@ -114,8 +122,8 @@ RandomGenerator::next()
   return static_cast<std::uint64_t>(std::chrono::steady_clock::now().time_since_epoch().count());
 }
 
-bool
-RandomGenerator::getBytes(void* dest, std::size_t size)
+auto
+RandomGenerator::getBytes(void* dest, std::size_t size) -> bool
 {
   return shared_provider->getBytes(dest, size);
 }

package/deps/couchbase-cxx-client/core/platform/string_hex.cc

@@ -17,6 +17,7 @@
 
 #include "string_hex.h"
 
+#include <array>
 #include <cinttypes>
 #include <cstdint>
 #include <cstdio>
@@ -27,8 +28,10 @@
 #include <string>
 #include <string_view>
 
-static inline std::uint8_t
-from_hex_digit(char c)
+namespace
+{
+inline auto
+from_hex_digit(char c) -> std::uint8_t
 {
   if ('0' <= c && c <= '9') {
     return static_cast<std::uint8_t>(c - '0');
@@ -42,9 +45,10 @@ from_hex_digit(char c)
   throw std::invalid_argument(
     "couchbase::core::from_hex_digit: character was not in hexadecimal range");
 }
+} // namespace
 
-std::uint64_t
-couchbase::core::from_hex(std::string_view buffer)
+auto
+couchbase::core::from_hex(std::string_view buffer) -> std::uint64_t
 {
   std::uint64_t ret = 0;
   if (buffer.size() > 16) {
@@ -59,40 +63,40 @@ couchbase::core::from_hex(std::string_view buffer)
   return ret;
 }
 
-std::string
-couchbase::core::to_hex(std::uint8_t val)
+auto
+couchbase::core::to_hex(std::uint8_t val) -> std::string
 {
-  char buf[32];
-  snprintf(buf, sizeof(buf), "0x%02" PRIx8, val);
-  return std::string{ buf };
+  std::array<char, 32> buf{};
+  snprintf(buf.data(), buf.size(), "0x%02" PRIx8, val);
+  return std::string{ buf.data() };
 }
 
-std::string
-couchbase::core::to_hex(std::uint16_t val)
+auto
+couchbase::core::to_hex(std::uint16_t val) -> std::string
 {
-  char buf[32];
-  snprintf(buf, sizeof(buf), "0x%04" PRIx16, val);
-  return std::string{ buf };
+  std::array<char, 32> buf{};
+  snprintf(buf.data(), buf.size(), "0x%04" PRIx16, val);
+  return std::string{ buf.data() };
 }
 
-std::string
-couchbase::core::to_hex(std::uint32_t val)
+auto
+couchbase::core::to_hex(std::uint32_t val) -> std::string
 {
-  char buf[32];
-  snprintf(buf, sizeof(buf), "0x%08" PRIx32, val);
-  return std::string{ buf };
+  std::array<char, 32> buf{};
+  snprintf(buf.data(), buf.size(), "0x%08" PRIx32, val);
+  return std::string{ buf.data() };
 }
 
-std::string
-couchbase::core::to_hex(std::uint64_t val)
+auto
+couchbase::core::to_hex(std::uint64_t val) -> std::string
 {
-  char buf[32];
-  snprintf(buf, sizeof(buf), "0x%016" PRIx64, val);
-  return std::string{ buf };
+  std::array<char, 32> buf{};
+  snprintf(buf.data(), buf.size(), "0x%016" PRIx64, val);
+  return std::string{ buf.data() };
 }
 
-std::string
-couchbase::core::to_hex(std::string_view buffer)
+auto
+couchbase::core::to_hex(std::string_view buffer) -> std::string
 {
   if (buffer.empty()) {
     return "";

package/deps/couchbase-cxx-client/core/platform/string_hex.h

@@ -17,6 +17,7 @@
 #pragma once
 
 #include <cstdint>
+#include <string>
 #include <string_view>
 
 namespace couchbase::core

package/deps/couchbase-cxx-client/core/platform/terminate_handler.cc

@@ -21,18 +21,21 @@
 #include "core/logger/logger.hxx"
 #include "core/meta/version.hxx"
 
+#include <array>
 #include <cstdio>
 #include <cstdlib>
 #include <exception>
 
 namespace couchbase::core::platform
 {
-static bool should_include_backtrace = true;
-static std::terminate_handler default_terminate_handler = nullptr;
+namespace
+{
+bool should_include_backtrace = true;
+std::terminate_handler default_terminate_handler = nullptr;
 
 // Logs details on the handled exception. Attempts to log to
 // `terminate_logger` if non-null; otherwise prints to stderr.
-static void
+void
 log_handled_exception()
 {
 #ifdef WIN32
@@ -58,18 +61,16 @@ log_handled_exception()
 }
 
 // Log the symbolified backtrace to this point.
-static void
+void
 log_backtrace()
 {
-  static const char format_str[] = "Call stack:\n%s";
-
-  char buffer[8192];
-  if (print_backtrace_to_buffer("    ", buffer, sizeof(buffer))) {
-    CB_LOG_CRITICAL("Call stack:\n{}", buffer);
+  std::array<char, 8192> buffer{};
+  if (print_backtrace_to_buffer("    ", buffer.data(), buffer.size())) {
+    CB_LOG_CRITICAL("Call stack:\n{}", buffer.data());
   } else {
     // Exceeded buffer space - print directly to stderr FD (requires no
     // buffering, but has the disadvantage that we don't get it in the log).
-    fprintf(stderr, format_str, "");
+    fprintf(stderr, "Call stack:\n%s", "");
     print_backtrace_to_file(stderr);
     fflush(stderr);
     CB_LOG_CRITICAL_RAW("Call stack exceeds 8k, rendered to STDERR");
@@ -78,7 +79,7 @@ log_backtrace()
 
 // Replacement terminate_handler which prints the exception's what() and a
 // backtrace of the current stack before chaining to the default handler.
-static void
+void
 backtrace_terminate_handler()
 {
   static bool meta_reported = false;
@@ -108,6 +109,7 @@ backtrace_terminate_handler()
 
   std::abort();
 }
+} // namespace
 
 void
 install_backtrace_terminate_handler()