Print log level in terminal and file

Author: PythonGermany

.vscode/settings.json

@@ -67,7 +67,14 @@
     "stop_token": "cpp",
     "thread": "cpp",
     "variant": "cpp",
-    "queue": "cpp"
+    "queue": "cpp",
+    "charconv": "cpp",
+    "codecvt": "cpp",
+    "format": "cpp",
+    "stdfloat": "cpp",
+    "text_encoding": "cpp",
+    "cfenv": "cpp",
+    "valarray": "cpp"
   },
-  "cmake.configureOnOpen": false
+  "C_Cpp.clang_format_fallbackStyle": "Google",
 }

include/output/Log.hpp

@@ -41,19 +41,19 @@ class Log {
   static log_level_t _log_level;
 
   std::string _path;
-  std::ostream& _terminal;
+  std::ostream &_terminal;
   std::ofstream _file;
 
   static std::string _timeFormat;
   static std::string _dateFormat;
 
-  bool _fileSet;      // True once file has been set
-  bool _initialized;  // Enables/Disables logfile functionality
+  bool _fileSet;
+  bool _logToFile;
 
-  bool _error;  // True if an error occured while writing to the log file
+  bool _logFileWriteError;
 
  public:
-  Log(std::ostream& terminal);
+  Log(std::ostream &terminal);
   ~Log();
 
   void init(std::string path);
@@ -62,16 +62,17 @@ class Log {
   static void setLogToTerminal(bool log, bool overwrite = false);
   static void setLevel(log_level_t level, bool overwrite = false);
   void setFile(std::string path, bool overwrite = false);
-  void setInitialized(bool intialized);
+  void setLogToFile(bool logToFile);
 
   // Getters
   static log_level_t getLevel();
-  bool getInitialized();
+  static std::string getLevelName(log_level_t level);
+  bool getLogToFile();
 
   // Writes a message to the log file and if enabled also to the _terminal
   // stream
   // @exception No custom exceptions
-  void write(std::string const& msg, log_level_t level,
+  void write(std::string const &msg, log_level_t level,
              std::string color = RESET);
 
  private:

src/config/Init.cpp

@@ -39,8 +39,8 @@ void Init::initLogDefaults(Context& context) {
     accessLog_g.setFile(context.getDirective("access_log")[0][0]);
   if (context.exists("error_log"))
     errorLog_g.setFile(context.getDirective("error_log")[0][0]);
-  accessLog_g.setInitialized(true);
-  errorLog_g.setInitialized(true);
+  accessLog_g.setLogToFile(true);
+  errorLog_g.setLogToFile(true);
 }
 
 void Init::initMimeTypes(Context& context) {

src/config/argument.cpp

@@ -69,7 +69,7 @@ arg_state_t setAccessLog(const std::list<std::string> &values) {
   static bool set = false;
   if (set) return FLAG_DUPLICATE;
   accessLog_g.setFile(values.front());
-  accessLog_g.setInitialized(true);
+  accessLog_g.setLogToFile(true);
   set = true;
   return SUCCESS;
 }
@@ -78,7 +78,7 @@ arg_state_t setErrorLog(const std::list<std::string> &values) {
   static bool set = false;
   if (set) return FLAG_DUPLICATE;
   errorLog_g.setFile(values.front());
-  errorLog_g.setInitialized(true);
+  errorLog_g.setLogToFile(true);
   set = true;
   return SUCCESS;
 }

src/main.cpp

@@ -48,7 +48,7 @@ int main(int argc, char** argv) {
     }
   } catch (const std::exception& e) {
     try {
-      if (errorLog_g.getInitialized() == false)
+      if (errorLog_g.getLogToFile() == false)
         Log::setLogToTerminal(true, true);
       errorLog_g.write(e.what(), ERROR);
       printHelp(PRINT);

src/output/Log.cpp

@@ -19,50 +19,70 @@ void Log::init(std::string path) {
 
 void Log::setLogToTerminal(bool log, bool overwrite) {
   static bool initialized = false;
-  if (overwrite || !initialized) {
+  if (overwrite || initialized == false) {
     _log_to_terminal = log;
     initialized = true;
   }
 }
 
 void Log::setLevel(log_level_t level, bool overwrite) {
   static bool initialized = false;
-  if (overwrite || !initialized) {
+  if (overwrite || initialized == false) {
     _log_level = level;
     initialized = true;
   }
 }
 
 void Log::setFile(std::string path, bool overwrite) {
-  if (overwrite || !_fileSet) {
+  if (overwrite || _fileSet == false) {
     File(path).createDirPath();
     _path = path;
     if (_file.is_open()) _file.close();
     _file.open(path.c_str(), std::ios_base::app);
-    if (_file.good()) _error = false;
+    if (_file.good()) _logFileWriteError = false;
     _fileSet = true;
   }
 }
 
-void Log::setInitialized(bool initialized) { _initialized = initialized; }
+void Log::setLogToFile(bool logToFile) { _logToFile = logToFile; }
 
 log_level_t Log::getLevel() { return _log_level; }
 
-bool Log::getInitialized() { return _initialized; }
+static std::string getLevelString(log_level_t level) {
+  switch (level)
+  {
+  case ERROR:
+    return "Error  ";
+  case WARNING:
+    return "Warning";
+  case INFO:
+    return "Info   ";
+  case DEBUG:
+    return "Debug  ";
+  case VERBOSE:
+    return "Verbose";
+  
+  default:
+    return "Unknown";
+  }
+}
+
+bool Log::getLogToFile() { return _logToFile; }
 
 void Log::write(std::string const &msg, log_level_t level, std::string color) {
   if (level > _log_level) return;
-  std::string timeStamp = "[" + getTime(_dateFormat + " " + _timeFormat) + "] ";
+  std::string timeStamp = "[" + getTime(_dateFormat + " " + _timeFormat) + "]";
+  std::string levelString = "[" + getLevelString(level) + "] ";
   if (_log_to_terminal) {
     if (color == RESET) color = getLevelColor(level);
-    _terminal << timeStamp << color << msg << RESET << std::endl;
+    _terminal << timeStamp << color << levelString << msg << RESET << std::endl;
   }
-  if (!_initialized) return;
-  _file << timeStamp << msg << std::endl;
-  if (_file.good() || _error) return;
+  if (getLogToFile() == false) return;
+  _file << timeStamp << levelString << msg << std::endl;
+  if (_file.good() || _logFileWriteError == true) return;
   std::cerr << timeStamp << BRIGHT_RED << "ERROR: " << RESET
             << "Unable to write to log file: " << _path << std::endl;
-  _error = true;
+  _logFileWriteError = true;
 }
 
 std::string Log::getLevelColor(log_level_t level) {

src/poll/AConnection.cpp

@@ -435,8 +435,8 @@ void AConnection::runCGI(std::string program,
   }
   if (_cgiPid == 0) {
     Log::setLogToTerminal(false, true);
-    accessLog_g.setInitialized(false);
-    errorLog_g.setInitialized(false);
+    accessLog_g.setLogToFile(false);
+    errorLog_g.setLogToFile(false);
     Poll::cleanUp();
     close(pipeInArray[0]);
     close(pipeOutArray[1]);