Added --console-log-level option

--console-log-level option sets log level to output to console.

src/LogFactory.cc

@@ -43,6 +43,7 @@ std::string LogFactory::filename_ = DEV_NULL;
 SharedHandle<Logger> LogFactory::logger_;
 bool LogFactory::consoleOutput_ = true;
 Logger::LEVEL LogFactory::logLevel_ = Logger::A2_DEBUG;
+Logger::LEVEL LogFactory::consoleLogLevel_ = Logger::A2_NOTICE;
 
 void LogFactory::openLogger(const SharedHandle<Logger>& logger)
 {
@@ -52,6 +53,8 @@ void LogFactory::openLogger(const SharedHandle<Logger>& logger)
     logger->openFile(filename_);
   }
   logger->setLogLevel(logLevel_);
+  logger->setConsoleLogLevel(consoleLogLevel_);
+  logger->setConsoleOutput(consoleOutput_);
 }
 
 void LogFactory::reconfigure()
@@ -72,11 +75,6 @@ const SharedHandle<Logger>& LogFactory::getInstance()
   if(!logger_) {
     SharedHandle<Logger> slogger(new Logger());
     openLogger(slogger);
-    if(consoleOutput_) {
-      slogger->setStdoutLogLevel(Logger::A2_NOTICE, true);
-      slogger->setStdoutLogLevel(Logger::A2_WARN, true);
-      slogger->setStdoutLogLevel(Logger::A2_ERROR, true);
-    }
     logger_.swap(slogger);
   }
   return logger_;
@@ -93,25 +91,44 @@ void LogFactory::setLogFile(const std::string& name)
   }
 }
 
-void LogFactory::setLogLevel(Logger::LEVEL level)
-{
-  logLevel_ = level;
-}
-
-void LogFactory::setLogLevel(const std::string& level)
+namespace {
+Logger::LEVEL toLogLevel(const std::string& level)
 {
   if(level == V_DEBUG) {
-    logLevel_ = Logger::A2_DEBUG;
+    return Logger::A2_DEBUG;
   } else if(level == V_INFO) {
-    logLevel_ = Logger::A2_INFO;
+    return Logger::A2_INFO;
   } else if(level == V_NOTICE) {
-    logLevel_ = Logger::A2_NOTICE;
+    return Logger::A2_NOTICE;
   } else if(level == V_WARN) {
-    logLevel_ = Logger::A2_WARN;
+    return Logger::A2_WARN;
   } else if(level == V_ERROR) {
-    logLevel_ = Logger::A2_ERROR;
+    return Logger::A2_ERROR;
+  } else {
+    return Logger::A2_NOTICE;
   }
 }
+} // namespace
+
+void LogFactory::setLogLevel(Logger::LEVEL level)
+{
+  logLevel_ = level;
+}
+
+void LogFactory::setLogLevel(const std::string& level)
+{
+  logLevel_ = toLogLevel(level);
+}
+
+void LogFactory::setConsoleLogLevel(Logger::LEVEL level)
+{
+  consoleLogLevel_ = level;
+}
+
+void LogFactory::setConsoleLogLevel(const std::string& level)
+{
+  consoleLogLevel_ = toLogLevel(level);
+}
 
 void LogFactory::release() {
   logger_.reset();

src/LogFactory.h

@@ -50,6 +50,7 @@ private:
   static SharedHandle<Logger> logger_;
   static bool consoleOutput_;
   static Logger::LEVEL logLevel_;
+  static Logger::LEVEL consoleLogLevel_;
 
   static void openLogger(const SharedHandle<Logger>& logger);
 
@@ -77,16 +78,27 @@ public:
   }
 
   /**
-   * Set log level to output.
+   * Set log level to output to file.
    */
   static void setLogLevel(Logger::LEVEL level);
 
   /**
-   * Set log level to output by string represention of log level.
-   * Possible values are: debug, info, notice, warn, error
+   * Set log level to output to file by string represention of log
+   * level.  Possible values are: debug, info, notice, warn, error
    */
   static void setLogLevel(const std::string& level);
 
+  /**
+   * Set log level to output to console.
+   */
+  static void setConsoleLogLevel(Logger::LEVEL level);
+
+  /**
+   * Set log level to output to console by string represention of log
+   * level.  Possible values are: debug, info, notice, warn, error
+   */
+  static void setConsoleLogLevel(const std::string& level);
+
   /**
    * Releases used resources
    */

src/Logger.cc

@@ -51,7 +51,8 @@ namespace aria2 {
 
 Logger::Logger()
   : logLevel_(Logger::A2_DEBUG),
-    stdoutField_(0),
+    consoleLogLevel_(Logger::A2_NOTICE),
+    consoleOutput_(true),
 #ifdef __MINGW32__
     // Windows DOS prompt does not handle ANSI color code, so make
     // this false.
@@ -85,18 +86,24 @@ void Logger::closeFile()
   }
 }
 
-void Logger::setStdoutLogLevel(Logger::LEVEL level, bool enabled)
+void Logger::setConsoleOutput(bool enabled)
 {
-  if(enabled) {
-    stdoutField_ |= level;
-  } else {
-    stdoutField_ &= ~level;
-  }
+  consoleOutput_ = enabled;
+}
+
+bool Logger::fileLogEnabled(LEVEL level)
+{
+  return level >= logLevel_ && fpp_;
+}
+
+bool Logger::consoleLogEnabled(LEVEL level)
+{
+  return consoleOutput_ && level >= consoleLogLevel_;
 }
 
 bool Logger::levelEnabled(LEVEL level)
 {
-  return (level >= logLevel_ && fpp_) || stdoutField_&level;
+  return fileLogEnabled(level) || consoleLogEnabled(level);
 }
 
 namespace {
@@ -144,9 +151,9 @@ const char* levelColor(Logger::LEVEL level)
 {
   switch(level) {
   case Logger::A2_DEBUG:
+    return "\033[1;37m";
   case Logger::A2_INFO:
-    // We don't print these levels in console
-    return "";
+    return "\033[1;36m";
   case Logger::A2_NOTICE:
     return "\033[1;32m";
   case Logger::A2_WARN:
@@ -173,9 +180,9 @@ void writeHeaderConsole(Output& fp, Logger::LEVEL level, bool useColor)
 
 namespace {
 template<typename Output>
-void writeStackTrace(Output& fp, const std::string& stackTrace)
+void writeStackTrace(Output& fp, const char* stackTrace)
 {
-  fp.write(stackTrace.c_str());
+  fp.write(stackTrace);
 }
 } // namespace
 
@@ -184,17 +191,15 @@ void Logger::writeLog
  const char* sourceFile,
  int lineNum,
  const char* msg,
- const std::string& trace,
- bool toStream,
- bool toConsole)
+ const char* trace)
 {
-  if(toStream) {
+  if(fileLogEnabled(level)) {
     writeHeader(*fpp_, level, sourceFile, lineNum);
     fpp_->printf("%s\n", msg);
     writeStackTrace(*fpp_, trace);
     fpp_->flush();
   }
-  if(toConsole) {
+  if(consoleLogEnabled(level)) {
     global::cout()->printf("\n");
     writeHeaderConsole(*global::cout(), level, useColor_);
     global::cout()->printf("%s\n", msg);
@@ -209,9 +214,7 @@ void Logger::log
  int lineNum,
  const char* msg)
 {
-  writeLog(level, sourceFile, lineNum, msg, A2STR::NIL,
-           level >= logLevel_ && fpp_,
-           stdoutField_&level);
+  writeLog(level, sourceFile, lineNum, msg, "");
 }
 
 void Logger::log
@@ -230,9 +233,7 @@ void Logger::log
  const char* msg,
  const Exception& ex)
 {
-  writeLog(level, sourceFile, lineNum, msg, ex.stackTrace(),
-           level >= logLevel_ && fpp_,
-           stdoutField_&level);
+  writeLog(level, sourceFile, lineNum, msg, ex.stackTrace().c_str());
 }
 
 void Logger::log

src/Logger.h

@@ -56,9 +56,13 @@ public:
     A2_ERROR  = 1 << 4,
   };
 private:
+  // Minimum log level for file log output.
   LEVEL logLevel_;
   SharedHandle<OutputFile> fpp_;
-  int stdoutField_;
+  // Minimum log level for console log output.
+  LEVEL consoleLogLevel_;
+  // true if console log output is enabled.
+  bool consoleOutput_;
   bool useColor_;
   // Don't allow copying
   Logger(const Logger&);
@@ -69,9 +73,14 @@ private:
    const char* sourceFile,
    int lineNum,
    const char* msg,
-   const std::string& trace,
-   bool toStream,
-   bool toConsole);
+   const char* trace);
+
+  // Returns true if message with log level |level| will be outputted
+  // to file.
+  bool fileLogEnabled(LEVEL level);
+  // Returns true if message with log level |level| will be outputted
+  // to console.
+  bool consoleLogEnabled(LEVEL level);
 public:
   Logger();
 
@@ -112,7 +121,12 @@ public:
     logLevel_ = level;
   }
 
-  void setStdoutLogLevel(Logger::LEVEL level, bool enabled);
+  void setConsoleLogLevel(LEVEL level)
+  {
+    consoleLogLevel_ = level;
+  }
+
+  void setConsoleOutput(bool enabled);
 
   // Returns true if this logger actually writes debug log message to
   // either file or stdout.

src/OptionHandlerFactory.cc

@@ -48,6 +48,8 @@ namespace aria2 {
 std::vector<OptionHandler*> OptionHandlerFactory::createOptionHandlers()
 {
   std::vector<OptionHandler*> handlers;
+  static const std::string logLevels[] =
+    { V_DEBUG, V_INFO, V_NOTICE, V_WARN, V_ERROR };
   // General Options
   {
     OptionHandler* op(new BooleanOptionHandler
@@ -213,6 +215,16 @@ std::vector<OptionHandler*> OptionHandlerFactory::createOptionHandlers()
     op->addTag(TAG_ADVANCED);
     handlers.push_back(op);
   }
+  {
+    OptionHandler* op(new ParameterOptionHandler
+                      (PREF_CONSOLE_LOG_LEVEL,
+                       TEXT_CONSOLE_LOG_LEVEL,
+                       V_NOTICE,
+                       std::vector<std::string>
+                       (vbegin(logLevels), vend(logLevels))));
+    op->addTag(TAG_ADVANCED);
+    handlers.push_back(op);
+  }
   {
     OptionHandler* op(new BooleanOptionHandler
                       (PREF_DEFERRED_INPUT,
@@ -472,13 +484,12 @@ std::vector<OptionHandler*> OptionHandlerFactory::createOptionHandlers()
     handlers.push_back(op);
   }
   {
-    const std::string params[] = { V_DEBUG, V_INFO, V_NOTICE, V_WARN, V_ERROR };
     OptionHandler* op(new ParameterOptionHandler
                       (PREF_LOG_LEVEL,
                        TEXT_LOG_LEVEL,
                        V_DEBUG,
                        std::vector<std::string>
-                       (vbegin(params), vend(params))));
+                       (vbegin(logLevels), vend(logLevels))));
     op->addTag(TAG_ADVANCED);
     op->setChangeGlobalOption(true);
     handlers.push_back(op);

src/main.cc

@@ -190,6 +190,7 @@ error_code::Value main(int argc, char* argv[])
 #endif // ENABLE_BITTORRENT
   LogFactory::setLogFile(op->get(PREF_LOG));
   LogFactory::setLogLevel(op->get(PREF_LOG_LEVEL));
+  LogFactory::setConsoleLogLevel(op->get(PREF_CONSOLE_LOG_LEVEL));
   if(op->getAsBool(PREF_QUIET)) {
     LogFactory::setConsoleOutput(false);
   }

src/prefs.cc

@@ -254,6 +254,8 @@ const Pref* PREF_ASYNC_DNS = makePref("async-dns");
 const Pref* PREF_SUMMARY_INTERVAL = makePref("summary-interval");
 // value: debug, info, notice, warn, error
 const Pref* PREF_LOG_LEVEL = makePref("log-level");
+// value: debug, info, notice, warn, error
+const Pref* PREF_CONSOLE_LOG_LEVEL = makePref("console-log-level");
 // value: inorder | feedback | adaptive
 const Pref* PREF_URI_SELECTOR = makePref("uri-selector");
 // value: 1*digit

src/prefs.h

@@ -189,6 +189,8 @@ extern const Pref* PREF_ASYNC_DNS;
 extern const Pref* PREF_SUMMARY_INTERVAL;
 // value: debug, info, notice, warn, error
 extern const Pref* PREF_LOG_LEVEL;
+// value: debug, info, notice, warn, error
+extern const Pref* PREF_CONSOLE_LOG_LEVEL;
 // value: inorder | feedback | adaptive
 extern const Pref* PREF_URI_SELECTOR;
 // value: 1*digit

src/usage_text.h

@@ -422,7 +422,8 @@
   _(" --summary-interval=SEC       Set interval to output download progress summary.\n" \
     "                              Setting 0 suppresses the output.")
 #define TEXT_LOG_LEVEL                                          \
-  _(" --log-level=LEVEL            Set log level to output.")
+  _(" --log-level=LEVEL            Set log level to output to file specified using\n" \
+    "                             --log option.")
 #define TEXT_REMOTE_TIME                                                \
   _(" -R, --remote-time[=true|false] Retrieve timestamp of the remote file from the\n" \
     "                              remote HTTP/FTP server and if it is available,\n" \
@@ -939,3 +940,5 @@
     "                              sessions saved using --save-session option. If\n" \
     "                              this option is not used, new GID is generated\n" \
     "                              by aria2.")
+#define TEXT_CONSOLE_LOG_LEVEL                                          \
+  _(" --console-log-level=LEVEL    Set log level to output to console.")