couchbase 3.5.3 → 3.5.4

data/ext/couchbase/core/io/streams.hxx

@@ -20,10 +20,15 @@
 #include "core/utils/movable_function.hxx"
 #include "ip_protocol.hxx"
 
-#include <asio.hpp>
-#include <asio/ssl.hpp>
+#include <asio/error.hpp>
+#include <asio/io_context.hpp>
+#include <asio/ip/tcp.hpp>
+#include <asio/ssl/context.hpp>
+#include <asio/ssl/stream.hpp>
+#include <asio/strand.hpp>
 
-#include <functional>
+#include <string>
+#include <vector>
 
 namespace couchbase::core::io
 {
@@ -59,43 +64,26 @@ protected:
   asio::strand<asio::io_context::executor_type> strand_;
   bool tls_;
   std::string id_{};
-  std::atomic_bool open_{ false };
 
 public:
-  stream_impl(asio::io_context& ctx, bool is_tls)
-    : strand_(asio::make_strand(ctx))
-    , tls_(is_tls)
-    , id_(uuid::to_string(uuid::random()))
-  {
-  }
+  stream_impl(asio::io_context& ctx, bool is_tls);
 
   virtual ~stream_impl() = default;
 
-  [[nodiscard]] auto log_prefix() const -> std::string_view
-  {
-    return tls_ ? "tls" : "plain";
-  }
-
-  [[nodiscard]] auto id() const -> const std::string&
-  {
-    return id_;
-  }
+  [[nodiscard]] auto log_prefix() const -> std::string_view;
 
-  [[nodiscard]] auto is_open() const -> bool
-  {
-    return open_;
-  }
+  [[nodiscard]] auto id() const -> const std::string&;
 
-  auto get_executor() const noexcept
+  [[nodiscard]] auto get_executor() const noexcept
   {
     return strand_;
   }
 
   [[nodiscard]] virtual auto local_endpoint() const -> asio::ip::tcp::endpoint = 0;
 
-  virtual void close(utils::movable_function<void(std::error_code)>&& handler) = 0;
+  [[nodiscard]] virtual auto is_open() const -> bool = 0;
 
-  virtual void reopen() = 0;
+  virtual void close(utils::movable_function<void(std::error_code)>&& handler) = 0;
 
   virtual void set_options() = 0;
 
@@ -117,165 +105,53 @@ private:
   std::shared_ptr<asio::ip::tcp::socket> stream_;
 
 public:
-  explicit plain_stream_impl(asio::io_context& ctx)
-    : stream_impl(ctx, false)
-    , stream_(std::make_shared<asio::ip::tcp::socket>(strand_))
-  {
-  }
+  explicit plain_stream_impl(asio::io_context& ctx);
 
-  [[nodiscard]] auto local_endpoint() const -> asio::ip::tcp::endpoint override
-  {
-    std::error_code ec;
-    auto res = stream_->local_endpoint(ec);
-    if (ec) {
-      return {};
-    }
-    return res;
-  }
+  [[nodiscard]] auto local_endpoint() const -> asio::ip::tcp::endpoint override;
 
-  void close(utils::movable_function<void(std::error_code)>&& handler) override
-  {
-    open_ = false;
-    return asio::post(strand_, [stream = stream_, h = std::move(handler)]() {
-      asio::error_code ec{};
-      stream->shutdown(asio::socket_base::shutdown_both, ec);
-      stream->close(ec);
-      h(ec);
-    });
-  }
+  [[nodiscard]] auto is_open() const -> bool override;
 
-  void reopen() override
-  {
-    return close([this](std::error_code) {
-      id_ = uuid::to_string(uuid::random());
-      stream_ = std::make_shared<asio::ip::tcp::socket>(strand_);
-    });
-  }
+  void close(utils::movable_function<void(std::error_code)>&& handler) override;
 
-  void set_options() override
-  {
-    if (!open_ || !stream_) {
-      return;
-    }
-    std::error_code ec{};
-    stream_->set_option(asio::ip::tcp::no_delay{ true }, ec);
-    stream_->set_option(asio::socket_base::keep_alive{ true }, ec);
-  }
+  void set_options() override;
 
   void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
-                     utils::movable_function<void(std::error_code)>&& handler) override
-  {
-    return stream_->async_connect(endpoint, [this, h = std::move(handler)](std::error_code ec) {
-      open_ = stream_->is_open();
-      h(ec);
-    });
-  }
+                     utils::movable_function<void(std::error_code)>&& handler) override;
 
   void async_write(std::vector<asio::const_buffer>& buffers,
-                   utils::movable_function<void(std::error_code, std::size_t)>&& handler) override
-  {
-    return asio::async_write(*stream_, buffers, std::move(handler));
-  }
+                   utils::movable_function<void(std::error_code, std::size_t)>&& handler) override;
 
   void async_read_some(
     asio::mutable_buffer buffer,
-    utils::movable_function<void(std::error_code, std::size_t)>&& handler) override
-  {
-    return stream_->async_read_some(buffer, std::move(handler));
-  }
+    utils::movable_function<void(std::error_code, std::size_t)>&& handler) override;
 };
 
 class tls_stream_impl : public stream_impl
 {
 private:
-  std::shared_ptr<asio::ssl::stream<asio::ip::tcp::socket>> stream_;
   asio::ssl::context& tls_;
+  std::shared_ptr<asio::ssl::stream<asio::ip::tcp::socket>> stream_;
 
 public:
-  tls_stream_impl(asio::io_context& ctx, asio::ssl::context& tls)
-    : stream_impl(ctx, true)
-    , stream_(
-        std::make_shared<asio::ssl::stream<asio::ip::tcp::socket>>(asio::ip::tcp::socket(strand_),
-                                                                   tls))
-    , tls_(tls)
-  {
-  }
+  tls_stream_impl(asio::io_context& ctx, asio::ssl::context& tls);
 
-  [[nodiscard]] auto local_endpoint() const -> asio::ip::tcp::endpoint override
-  {
-    std::error_code ec;
-    auto res = stream_->lowest_layer().local_endpoint(ec);
-    if (ec) {
-      return {};
-    }
-    return res;
-  }
+  [[nodiscard]] auto local_endpoint() const -> asio::ip::tcp::endpoint override;
 
-  void close(utils::movable_function<void(std::error_code)>&& handler) override
-  {
-    open_ = false;
-    return asio::post(strand_, [stream = stream_, h = std::move(handler)]() {
-      asio::error_code ec{};
-      stream->lowest_layer().shutdown(asio::socket_base::shutdown_both, ec);
-      stream->lowest_layer().close(ec);
-      h(ec);
-    });
-  }
+  [[nodiscard]] auto is_open() const -> bool override;
 
-  void reopen() override
-  {
-    return close([this](std::error_code) {
-      id_ = uuid::to_string(uuid::random());
-      stream_ = std::make_shared<asio::ssl::stream<asio::ip::tcp::socket>>(
-        asio::ip::tcp::socket(strand_), tls_);
-    });
-  }
+  void close(utils::movable_function<void(std::error_code)>&& handler) override;
 
-  void set_options() override
-  {
-    if (!open_ || !stream_) {
-      return;
-    }
-    std::error_code ec{};
-    stream_->lowest_layer().set_option(asio::ip::tcp::no_delay{ true }, ec);
-    stream_->lowest_layer().set_option(asio::socket_base::keep_alive{ true }, ec);
-  }
+  void set_options() override;
 
   void async_connect(const asio::ip::tcp::resolver::results_type::endpoint_type& endpoint,
-                     utils::movable_function<void(std::error_code)>&& handler) override
-  {
-    return stream_->lowest_layer().async_connect(
-      endpoint, [this, handler = std::move(handler)](std::error_code ec_connect) mutable {
-        if (ec_connect == asio::error::operation_aborted) {
-          return;
-        }
-        if (ec_connect) {
-          return handler(ec_connect);
-        }
-        open_ = stream_->lowest_layer().is_open();
-        stream_->async_handshake(
-          asio::ssl::stream_base::client,
-          [handler = std::move(handler)](std::error_code ec_handshake) mutable {
-            if (ec_handshake == asio::error::operation_aborted) {
-              return;
-            }
-            return handler(ec_handshake);
-          });
-      });
-  }
+                     utils::movable_function<void(std::error_code)>&& handler) override;
 
   void async_write(std::vector<asio::const_buffer>& buffers,
-                   utils::movable_function<void(std::error_code, std::size_t)>&& handler) override
-  {
-    return asio::async_write(*stream_, buffers, std::move(handler));
-  }
+                   utils::movable_function<void(std::error_code, std::size_t)>&& handler) override;
 
   void async_read_some(
     asio::mutable_buffer buffer,
-    utils::movable_function<void(std::error_code, std::size_t)>&& handler) override
-  {
-    return stream_->async_read_some(buffer, std::move(handler));
-  }
+    utils::movable_function<void(std::error_code, std::size_t)>&& handler) override;
 };
 
 } // namespace couchbase::core::io

data/ext/couchbase/core/logger/configuration.hxx

@@ -51,6 +51,11 @@ struct configuration {
    */
   level log_level{ level::info };
 
+  /**
+   * The default log level for console sink
+   */
+  level console_sink_log_level{ level::trace };
+
   /**
    * Custom sink to use, if desired
    */

data/ext/couchbase/core/logger/custom_rotating_file_sink.cxx

@@ -24,11 +24,14 @@
 
 #include "core/platform/dirutils.h"
 
+#include <algorithm>
 #include <gsl/assert>
 #include <memory>
 #include <spdlog/details/file_helper.h>
 
-static auto
+namespace
+{
+auto
 find_first_logfile_id(const std::string& basename) -> unsigned long
 {
   unsigned long id = 0;
@@ -46,10 +49,8 @@ find_first_logfile_id(const std::string& basename) -> unsigned long
     index = file.rfind('.');
     if (index != std::string::npos) {
       try {
-        unsigned long value = std::stoul(file.substr(index + 1));
-        if (value > id) {
-          id = value;
-        }
+        const unsigned long value = std::stoul(file.substr(index + 1));
+        id = std::max(value, id);
       } catch (const std::invalid_argument&) {
         continue; /* ignore */
       } catch (const std::out_of_range&) {
@@ -60,19 +61,20 @@ find_first_logfile_id(const std::string& basename) -> unsigned long
 
   return id;
 }
+} // namespace
 
 template<class Mutex>
 custom_rotating_file_sink<Mutex>::custom_rotating_file_sink(const spdlog::filename_t& base_filename,
                                                             std::size_t max_size,
                                                             const std::string& log_pattern)
-  : base_filename_(base_filename)
-  , max_size_(max_size)
-  , next_file_id_(find_first_logfile_id(base_filename))
+  : base_filename_{ base_filename }
+  , max_size_{ max_size }
+  , file_helper_{ open_file() }
+  , current_size_{ file_helper_->size() } // expensive. called only once
+  , formatter{ std::make_unique<spdlog::pattern_formatter>(log_pattern,
+                                                           spdlog::pattern_time_type::local) }
+  , next_file_id_{ find_first_logfile_id(base_filename) }
 {
-  formatter =
-    std::make_unique<spdlog::pattern_formatter>(log_pattern, spdlog::pattern_time_type::local);
-  file_helper_ = open_file();
-  current_size_ = file_helper_->size(); // expensive. called only once
   add_hook(opening_log_file_);
 }
 

data/ext/couchbase/core/logger/custom_rotating_file_sink.hxx

@@ -65,8 +65,8 @@ private:
 
   const spdlog::filename_t base_filename_;
   const std::size_t max_size_;
-  std::size_t current_size_{ 0 };
   std::unique_ptr<spdlog::details::file_helper> file_helper_;
+  std::size_t current_size_{ 0 };
   std::unique_ptr<spdlog::pattern_formatter> formatter;
   unsigned long next_file_id_;
 

data/ext/couchbase/core/logger/logger.cxx

@@ -25,6 +25,7 @@
 #include <spdlog/sinks/stdout_color_sinks.h>
 #include <spdlog/spdlog.h>
 
+#include <algorithm>
 #include <atomic>
 #include <chrono>
 #include <memory>
@@ -34,15 +35,17 @@
 #include <string_view>
 #include <utility>
 
-static const std::string file_logger_name{ "couchbase_cxx_client_file_logger" };
-static const std::string protocol_logger_name{ "couchbase_cxx_client_protocol_logger" };
+namespace
+{
+const std::string file_logger_name{ "couchbase_cxx_client_file_logger" };
+const std::string protocol_logger_name{ "couchbase_cxx_client_protocol_logger" };
 
 /**
  * Custom log pattern which the loggers will use.
  * This pattern is duplicated for some test cases. If you need to update it,
  * please also update in all relevant places.
  */
-static const std::string log_pattern{ "[%Y-%m-%d %T.%e] %4oms [%^%4!l%$] [%P,%t] %v" };
+const std::string log_pattern{ "[%Y-%m-%d %T.%e] %4oms [%^%4!l%$] [%P,%t] %v" };
 
 /**
  * Instances of spdlog (async) file logger.
@@ -52,12 +55,10 @@ static const std::string log_pattern{ "[%Y-%m-%d %T.%e] %4oms [%^%4!l%$] [%P,%t]
  * messages and send them to the sinks, which do the actual writing (to file,
  * to stream etc.) or further processing.
  */
-static std::shared_ptr<spdlog::logger> file_logger{};
-static std::mutex file_logger_mutex;
-static std::atomic_int file_logger_version{ 0 };
+std::shared_ptr<spdlog::logger> file_logger{};
+std::mutex file_logger_mutex;
+std::atomic_int file_logger_version{ 0 };
 
-namespace
-{
 auto
 get_file_logger() -> std::shared_ptr<spdlog::logger>
 {
@@ -77,16 +78,18 @@ update_file_logger(const std::shared_ptr<spdlog::logger>& new_logger)
   const std::scoped_lock lock(file_logger_mutex);
   // delete if already exists
   spdlog::drop(file_logger_name);
-  file_logger = new_logger;
-  spdlog::register_logger(new_logger);
+  if (new_logger) {
+    file_logger = new_logger;
+    spdlog::register_logger(new_logger);
+  }
   ++file_logger_version;
 }
-} // namespace
 
 /**
  * Instance of the protocol logger.
  */
-static std::shared_ptr<spdlog::logger> protocol_logger{};
+std::shared_ptr<spdlog::logger> protocol_logger{};
+} // namespace
 
 namespace couchbase::core::logger
 {
@@ -112,6 +115,28 @@ translate_level(level level) -> spdlog::level::level_enum
   return spdlog::level::level_enum::trace;
 }
 
+auto
+translate_level(spdlog::level::level_enum spdlog_level) -> level
+{
+  switch (spdlog_level) {
+    case spdlog::level::level_enum::trace:
+      return level::trace;
+    case spdlog::level::debug:
+      return level::debug;
+    case spdlog::level::info:
+      return level::info;
+    case spdlog::level::warn:
+      return level::warn;
+    case spdlog::level::err:
+      return level::err;
+    case spdlog::level::critical:
+      return level::critical;
+    default:
+      break;
+  }
+  return level::off;
+}
+
 auto
 level_from_str(const std::string& str) -> level
 {
@@ -248,11 +273,7 @@ create_file_logger_impl(const std::string& logger_name, const configuration& log
 
       // Set the formatting pattern of this sink
       stderrsink->set_pattern(log_pattern);
-      if (logger_settings.unit_test) {
-        stderrsink->set_level(spdlog::level::trace);
-      } else {
-        stderrsink->set_level(spdlog::level::err);
-      }
+      stderrsink->set_level(translate_level(logger_settings.console_sink_log_level));
       sink->add_sink(stderrsink);
     }
     if (nullptr != logger_settings.sink) {
@@ -410,6 +431,17 @@ check_log_levels(level lvl) -> bool
   return correct;
 }
 
+auto
+get_lowest_log_level() -> level
+{
+  auto lowest = spdlog::level::off;
+  // Apply the function to each registered spdlog::logger except protocol logger
+  spdlog::apply_all([&lowest](const std::shared_ptr<spdlog::logger>& l) {
+    lowest = std::min(l->level(), lowest);
+  });
+  return translate_level(lowest);
+}
+
 void
 set_log_levels(level lvl)
 {

data/ext/couchbase/core/logger/logger.hxx

@@ -148,6 +148,13 @@ check_log_levels(level lvl) -> bool;
 void
 set_log_levels(level lvl);
 
+/**
+ * Get the lowest (most verbose) level among the registered loggers
+ * @return log severity level
+ */
+auto
+get_lowest_log_level() -> level;
+
 /**
  * Checks whether a specific level should be logged based on the current
  * configuration.

data/ext/couchbase/core/meta/version.cxx

@@ -72,16 +72,15 @@ sdk_build_info() -> std::map<std::string, std::string>
   info["cxx"] = COUCHBASE_CXX_CLIENT_CXX_COMPILER;
   info["cmake_version"] = CMAKE_VERSION;
   info["cmake_build_type"] = CMAKE_BUILD_TYPE;
-  info["compile_definitions"] = COUCHBASE_CXX_CLIENT_COMPILE_DEFINITIONS;
-  info["compile_features"] = COUCHBASE_CXX_CLIENT_COMPILE_FEATURES;
-  info["compile_flags"] = COUCHBASE_CXX_CLIENT_COMPILE_FLAGS;
-  info["compile_options"] = COUCHBASE_CXX_CLIENT_COMPILE_OPTIONS;
-  info["link_depends"] = COUCHBASE_CXX_CLIENT_LINK_DEPENDS;
-  info["link_flags"] = COUCHBASE_CXX_CLIENT_LINK_FLAGS;
-  info["link_libraries"] = COUCHBASE_CXX_CLIENT_LINK_LIBRARIES;
-  info["link_options"] = COUCHBASE_CXX_CLIENT_LINK_OPTIONS;
+  info["static_target"] =
+#if defined(COUCHBASE_CXX_CLIENT_STATIC_TARGET)
+    "true"
+#else
+    "false"
+#endif
+    ;
   info["static_stdlib"] =
-#if defined(COUCHBASE_CXX_CLIENT_STATIC_STDLIB)
+#if defined(COUCHBASE_CXX_CLIENT_STATIC_TARGET) && defined(COUCHBASE_CXX_CLIENT_STATIC_STDLIB)
     "true"
 #else
     "false"
@@ -250,15 +249,17 @@ parse_git_describe_output(const std::string& git_describe_output) -> std::string
   return "";
 }
 
-const std::string&
-build_revision_short()
+auto
+build_revision_short() -> const std::string&
 {
   static const std::string revision{ COUCHBASE_CXX_CLIENT_GIT_REVISION_SHORT };
   return revision;
 }
 
-static std::string
-revision_with_prefix(std::string_view prefix)
+namespace
+{
+auto
+revision_with_prefix(std::string_view prefix) -> std::string
 {
   const auto& revision = build_revision_short();
   if (revision.empty() || revision == "unknown") {
@@ -266,6 +267,7 @@ revision_with_prefix(std::string_view prefix)
   }
   return fmt::format("{}{}", prefix, revision);
 }
+} // namespace
 
 auto
 build_date() -> const std::string&

data/ext/couchbase/core/metrics/logging_meter.cxx

@@ -205,7 +205,7 @@ logging_meter::get_value_recorder(const std::string& name,
                                   const std::map<std::string, std::string>& tags)
   -> std::shared_ptr<couchbase::metrics::value_recorder>
 {
-  static std::shared_ptr<noop_value_recorder> noop_recorder{
+  static const std::shared_ptr<noop_value_recorder> noop_recorder{
     std::make_shared<noop_value_recorder>()
   };
 
@@ -214,18 +214,18 @@ logging_meter::get_value_recorder(const std::string& name,
   }
 
   static const std::string service_tag = "db.couchbase.service";
-  auto service = tags.find(service_tag);
+  const auto service = tags.find(service_tag);
   if (service == tags.end()) {
     return noop_recorder;
   }
 
   static const std::string operation_tag = "db.operation";
-  auto operation = tags.find(operation_tag);
+  const auto operation = tags.find(operation_tag);
   if (operation == tags.end()) {
     return noop_recorder;
   }
 
-  std::scoped_lock lock(recorders_mutex_);
+  const std::scoped_lock lock(recorders_mutex_);
   auto& service_recorders = recorders_[service->second];
 
   auto recorder = service_recorders.find(operation->second);