Add callback sink and default pattern access

logger.hpp.in

@@ -424,6 +424,17 @@ class null_sink_mt : public sink {
   null_sink_mt();
 };
 
+typedef void (*log_callback_t)(int lvl, const char* msg);
+typedef void (*flush_callback_t)();
+
+/**
+ * @brief A sink that executes a callback whenever a message is logged.
+ */
+class callback_sink_mt : public sink {
+public:
+    explicit callback_sink_mt(const log_callback_t &callback, const flush_callback_t &flush = nullptr);
+};
+
 /**
  * @brief Returns the default log filename for the global logger.
  *
@@ -440,6 +451,13 @@ inline std::string default_log_filename()
   return (filename == nullptr) ? std::string{"@_RAPIDS_LOGGER_NAMESPACE@_log.txt"} : std::string{filename};
 }
 
+/**
+ * @brief Returns the default log pattern for the global logger.
+ *
+ * @return std::string The default log pattern.
+ */
+inline std::string default_pattern() { return "[%6t][%H:%M:%S:%f][%-6l] %v"; }
+
 /**
  * @brief Get the default logger.
  *
@@ -463,6 +481,24 @@ inline logger& default_logger()
   return logger_;
 }
 
+/**
+ * @brief An object used for scoped log level setting
+ *
+ * Instances will set the logging to the level indicated on construction and
+ * will revert to the previous set level on destruction.
+ */
+struct log_level_setter {
+  explicit log_level_setter(level_enum level)
+  {
+    prev_level_ = default_logger().level();
+    default_logger().set_level(level);
+  }
+  ~log_level_setter() { default_logger().set_level(prev_level_); }
+
+ private:
+  level_enum prev_level_;
+};
+
 // Macros for easier logging, similar to spdlog.
 #if !defined(@_RAPIDS_LOGGER_MACRO_PREFIX@_LOG_ACTIVE_LEVEL)
 #define @_RAPIDS_LOGGER_MACRO_PREFIX@_LOG_ACTIVE_LEVEL @_RAPIDS_LOGGER_MACRO_PREFIX@_LOG_LEVEL_INFO

logger_impl.hpp.in

@@ -36,9 +36,13 @@
 #include <spdlog/sinks/null_sink.h>
 #include <spdlog/sinks/ostream_sink.h>
 #include <spdlog/spdlog.h>
+#include <spdlog/details/log_msg.h>
+#include <spdlog/sinks/base_sink.h>
 #pragma GCC diagnostic pop
 
+#include <iostream>
 #include <memory>
+#include <mutex>
 #include <sstream>
 #include <string>
 
@@ -113,7 +117,7 @@ private:
 class logger_impl {
  public:
   logger_impl(std::string name) : underlying{spdlog::logger{name}} {
-    underlying.set_pattern("[%6t][%H:%M:%S:%f][%-6l] %v");
+    underlying.set_pattern(default_pattern());
     auto const env_logging_level =
       std::getenv("@_RAPIDS_LOGGER_MACRO_PREFIX@_DEFAULT_LOGGING_LEVEL");
     if (env_logging_level != nullptr) { set_level(detail::string_to_level(env_logging_level)); }
@@ -136,6 +140,43 @@ private:
   spdlog::logger underlying;  ///< The spdlog logger
 };
 
+// Default flush function
+void default_flush() { std::cout << std::flush; }
+
+/**
+ * @brief A sink that calls a callback function with log messages.
+ *
+ * We do not currently use spdlog's callback sink because it does not support
+ * flushing. We could contribute that function to the upstream callback_sink_mt
+ * to simplify this code.
+ */
+template <class Mutex>
+class callback_sink : public spdlog::sinks::base_sink<Mutex> {
+ public:
+  explicit callback_sink(log_callback_t callback,
+                         flush_callback_t flush         = nullptr)
+    : _callback{callback}, _flush{flush ? flush : default_flush} {}
+
+ protected:
+  void sink_it_(const spdlog::details::log_msg& msg) override
+  {
+    spdlog::memory_buf_t formatted;
+    spdlog::sinks::base_sink<Mutex>::formatter_->format(msg, formatted);
+    std::string msg_string = fmt::to_string(formatted);
+
+    if (_callback) {
+      _callback(static_cast<int>(msg.level), msg_string.c_str());
+    } else {
+      std::cout << msg_string;
+    }
+  }
+
+  void flush_() override { _flush();}
+
+  log_callback_t _callback;
+  void (*_flush)();
+};
+
 }  // namespace detail
 
 // Sink vector functions
@@ -170,6 +211,9 @@ ostream_sink_mt::ostream_sink_mt(std::ostream& stream, bool force_flush)
 null_sink_mt::null_sink_mt()
   : sink{std::make_unique<detail::sink_impl>(std::make_shared<spdlog::sinks::null_sink_mt>())} {}
 
+callback_sink_mt::callback_sink_mt(const log_callback_t &callback, const flush_callback_t &flush)
+  : sink{std::make_unique<detail::sink_impl>(std::make_shared<detail::callback_sink<std::mutex>>(callback, flush))} {}
+
 // Logger methods
 logger::logger(std::string name, std::string filename)
   : impl{std::make_unique<detail::logger_impl>(name)}, sinks_{*this} {