log to stderr for errors and warnings by default

config_utilities/include/config_utilities/internal/logger.h

@@ -42,8 +42,8 @@
 
 namespace config::internal {
 
-// Enum for different severity levels of logging.
-enum class Severity { kInfo, kWarning, kError, kFatal };
+// Enum for different severity levels of logging. Enum values are used for comparing logging levels.
+enum class Severity { kInfo = 0, kWarning = 1, kError = 2, kFatal = 3 };
 
 std::string severityToString(const Severity severity);
 

config_utilities/include/config_utilities/logging/log_to_stdout.h

@@ -45,13 +45,21 @@ namespace config::internal {
  */
 class StdoutLogger : public Logger {
  public:
-  StdoutLogger() = default;
+  /**
+   * @brief Construct a logger to output to stdout or stderr depending on configuration
+   * @param min_severity Mininum severity to output
+   * @param stderr_severity Mininum severity to log to stderr instead of stdout
+   */
+  StdoutLogger(Severity min_severity = Severity::kWarning, Severity stderr_severity = Severity::kError);
+
   virtual ~StdoutLogger() = default;
 
  protected:
   void logImpl(const Severity severity, const std::string& message) override;
 
  private:
+  const Severity min_severity_;
+  const Severity stderr_severity_;
   // Factory registration to allow setting of formatters via Settings::setLogger().
   inline static const auto registration_ = Registration<Logger, StdoutLogger>("stdout");
 

config_utilities/include/config_utilities/settings.h

@@ -91,6 +91,9 @@ struct Settings {
   //! @brief Log any factory creation from an external library (for debugging purposes)
   bool print_external_allocations = false;
 
+  //! @brief Control whether config_utilities is initialized to log to stdout/stderr by default
+  bool disable_default_stdout_logger = false;
+
   /* Options to specify the logger and formatter at run time. */
   // Specify the default logger to be used for printing. Loggers register themselves if included.
   void setLogger(const std::string& name);

config_utilities/src/log_to_stdout.cpp

@@ -40,27 +40,39 @@
 
 namespace config::internal {
 
+StdoutLogger::StdoutLogger(Severity min_severity, Severity stderr_severity)
+    : min_severity_(min_severity), stderr_severity_(stderr_severity) {}
+
 void StdoutLogger::logImpl(const Severity severity, const std::string& message) {
+  if (severity < min_severity_ && severity != Severity::kFatal) {
+    return;
+  }
+
+  std::stringstream ss;
   switch (severity) {
     case Severity::kInfo:
-      std::cout << "[INFO] " << message << std::endl;
+      ss << "[INFO] " << message;
       break;
 
     case Severity::kWarning:
-      std::cout << "\033[33m[WARNING] " << message << "\033[0m" << std::endl;
+      ss << "\033[33m[WARNING] " << message << "\033[0m";
       break;
 
     case Severity::kError:
-      std::cout << "\033[31m[ERROR] " << message << "\033[0m" << std::endl;
+      ss << "\033[31m[ERROR] " << message << "\033[0m";
       break;
 
     case Severity::kFatal:
       throw std::runtime_error(message);
   }
-}
 
-StdoutLogger::Initializer::Initializer() {
-  Logger::setLogger(std::make_shared<StdoutLogger>());
+  if (severity < stderr_severity_) {
+    std::cout << ss.str() << std::endl;
+  } else {
+    std::cerr << ss.str() << std::endl;
+  }
 }
 
+StdoutLogger::Initializer::Initializer() { Logger::setLogger(std::make_shared<StdoutLogger>()); }
+
 }  // namespace config::internal

config_utilities/src/logger.cpp

@@ -37,6 +37,8 @@
 
 #include <stdexcept>
 
+#include "config_utilities/logging/log_to_stdout.h"
+
 namespace config::internal {
 
 Logger::Ptr Logger::logger_;
@@ -73,7 +75,9 @@ void Logger::setLogger(Logger::Ptr logger) {
 
 void Logger::dispatch(const Severity severity, const std::string& message) {
   if (!logger_) {
-    logger_ = std::make_shared<Logger>();
+    // NOTE(nathan) we default to logging to stdout/stderr to make sure warnings and errors are visible
+    logger_ = Settings::instance().disable_default_stdout_logger ? std::make_shared<Logger>()
+                                                                 : std::make_shared<StdoutLogger>();
   }
 
   logger_->logImpl(severity, message);