Insert logging of file, line and function

Update readme
Slightly documentation fixes
Some readability fixes

Author: florianbecker

3rdparty/source_location.hpp

@@ -0,0 +1,71 @@
+#ifndef NOSTD_SOURCE_LOCATION_HPP
+#define NOSTD_SOURCE_LOCATION_HPP
+
+#pragma once
+
+#include <cstdint>
+
+namespace nostd {
+struct source_location {
+public:
+#if defined(__clang__) and (__clang_major__ >= 9)
+    static constexpr source_location current(const char* fileName = __builtin_FILE(),
+        const char* functionName = __builtin_FUNCTION(),
+        const uint_least32_t lineNumber = __builtin_LINE(),
+        const uint_least32_t columnOffset = __builtin_COLUMN()) noexcept
+#elif defined(__GNUC__) and (__GNUC__ > 4 or (__GNUC__ == 4 and __GNUC_MINOR__ >= 8))
+    static constexpr source_location current(const char* fileName = __builtin_FILE(),
+        const char* functionName = __builtin_FUNCTION(),
+        const uint_least32_t lineNumber = __builtin_LINE(),
+        const uint_least32_t columnOffset = 0) noexcept
+#else
+    static constexpr source_location current(const char* fileName = "unsupported",
+        const char* functionName = "unsupported",
+        const uint_least32_t lineNumber = 0,
+        const uint_least32_t columnOffset = 0) noexcept
+#endif
+    {
+        return source_location(fileName, functionName, lineNumber, columnOffset);
+    }
+
+    source_location(const source_location&) = default;
+    source_location(source_location&&) = default;
+
+    constexpr const char* file_name() const noexcept
+    {
+        return fileName;
+    }
+
+    constexpr const char* function_name() const noexcept
+    {
+        return functionName;
+    }
+
+    constexpr uint_least32_t line() const noexcept
+    {
+        return lineNumber;
+    }
+
+    constexpr std::uint_least32_t column() const noexcept
+    {
+        return columnOffset;
+    }
+
+private:
+    constexpr source_location(const char* _fileName, const char* _functionName, const uint_least32_t _lineNumber,
+        const uint_least32_t _columnOffset) noexcept
+        : fileName(_fileName)
+        , functionName(_functionName)
+        , lineNumber(_lineNumber)
+        , columnOffset(_columnOffset)
+    {
+    }
+
+    const char* fileName;
+    const char* functionName;
+    const std::uint_least32_t lineNumber;
+    const std::uint_least32_t columnOffset;
+};
+} // namespace nostd
+
+#endif

README.md

@@ -1,5 +1,12 @@
 # modern.cpp.logger
-Modern C++ logger classes for logging functions in most native and modern C++17.
+Modern C++ logger classes for logging functions (thread-safe) in most native and modern C++17.
+
+## Features
+- Log a message to /dev/null, stdout, file and file as xml.
+- Log a message with severity of Verbose, Debug, Info, Warning, Error and Fatal.
+- Log thread-safe from whole application.
+- Use compile flag to avoid level below a specified level. Default is LOGGINGINFO.
+- Log automatically file, line and function name from logging position (except Visual Studio builds)
 
 ## Build
 ```bash

examples/logger/main.cpp

@@ -34,10 +34,10 @@
 
 /* modern.cpp.logger */
 //#include <FileLogger.h>
-//#include <LoggerFactory.h>
+#include <LoggerFactory.h>
 //#include <Logger.h>
 //#include <StdLogger.h>
-#include <XmlFileLogger.h>
+//#include <XmlFileLogger.h>
 
 using namespace vx;
 
@@ -62,7 +62,7 @@ constexpr auto logMessage = "This is a log message";
 int main() {
 
   /* configure logging, if you dont it defaults to standard out logging with colors */
-//  vx::configure({ {"type", "file"}, {"filename", "test2.log"}, {"reopen_interval", "1"} });
+//  vx::configureLogger({ {"type", "file"}, {"filename", "test2.log"}, {"reopen_interval", "1"} });
 
   /* start up some threads */
 /*  std::vector<std::shared_ptr<std::thread>> threads( std::thread::hardware_concurrency() );
@@ -85,22 +85,22 @@ int main() {
   logger.log( logMessage, Severity::Fatal ); */
 
   /* Log to stdout */
-  /* std::unordered_map<std::string, std::string> configuration = { { "color", "" } };
-  StdLogger logger( configuration );
-  logger.log( logMessage, Severity::Fatal ); */
+//  std::unordered_map<std::string, std::string> configuration = { { "color", "" } };
+//  StdLogger logger( configuration );
+//  logger.log( logMessage, Severity::Fatal );
 
   /* Log to file */
   /* std::unordered_map<std::string, std::string> configuration = { { "color", "" }, {"filename", "logger.log"} };
   FileLogger logger( configuration );
   logger.log( logMessage, Severity::Fatal ); */
 
   /* Log to file */
-  std::unordered_map<std::string, std::string> configuration = { { "color", "" }, {"filename", "logger.xml"} };
-  XmlFileLogger logger( configuration );
-  logger.log( logMessage, Severity::Fatal );
+//  std::unordered_map<std::string, std::string> configuration = { { "color", "" }, {"filename", "logger.xml"} };
+//  XmlFileLogger logger( configuration );
+//  logger.log( logMessage, Severity::Fatal );
 
   /* Log with logging factory */
-//  vx::LogFatal( logMessage );
+  LogFatal( logMessage );
 
   return EXIT_SUCCESS;
 }

source/CMakeLists.txt

@@ -37,6 +37,7 @@ add_library(${PROJECT_NAME}
   ../README.md
   ../3rdparty/magic_enum.hpp
   ../3rdparty/Singleton.h
+  ../3rdparty/source_location.hpp
   FileLogger.cpp
   FileLogger.h
   Logger.cpp

source/FileLogger.cpp

@@ -40,6 +40,16 @@
 
 namespace vx {
 
+  /**
+   * @brief Reserved overhead for new log entry.
+   */
+  const int overhead = 64;
+
+  /**
+   * @brief Default reopen interval.
+   */
+  const int reopenInterval = 300;
+
   FileLogger::FileLogger( const std::unordered_map<std::string, std::string> &_config )
     : Logger( _config ) {
 
@@ -52,7 +62,7 @@ namespace vx {
     m_filename = name->second;
 
     /* if we specify an interval */
-    m_reopenInterval = std::chrono::seconds( 300 );
+    m_reopenInterval = std::chrono::seconds( reopenInterval );
     auto interval = _config.find( "reopen_interval" );
     if ( interval != _config.end() ) {
 
@@ -70,22 +80,34 @@ namespace vx {
     reopen();
   }
 
-  void FileLogger::log( const std::string &_message, const Severity _severity ) {
+  void FileLogger::log( const std::string &_message,
+                        const Severity _severity,
+                        const nostd::source_location &_location ) {
 
-    if ( avoidLogAbove > _severity ) {
+    if ( avoidLogBelow > _severity ) {
 
       return;
     }
 
     std::string output;
-    output.reserve( _message.length() + 64 );
+    output.reserve( _message.size() + overhead );
     output.append( timestamp() );
 
     std::string severity = std::string( magic_enum::enum_name( _severity ) );
     std::transform( severity.begin(), severity.end(), severity.begin(), []( unsigned char c ) { return ::toupper( c ); } );
     output.append( " [" + severity + "] " );
+    if ( std::string( _location.file_name() ) != "unsupported" ) {
+
+      output.append( _location.file_name() );
+      output.push_back( ':' );
+      output.append( std::to_string( _location.line() ) );
+      output.push_back( ' ' );
+      output.append( _location.function_name() );
+      output.push_back( ' ' );
+    }
     output.append( _message );
     output.push_back( '\n' );
+
     log( output );
   }
 

source/FileLogger.h

@@ -66,8 +66,11 @@ namespace vx {
      * @brief Build the log message.
      * @param _message   Message to log.
      * @param _severity   Severity level of the message.
+     * @param _location   Source location information.
      */
-    virtual void log( const std::string &_message, const Severity _severity ) override;
+    virtual void log( const std::string &_message,
+                      const Severity _severity,
+                      const nostd::source_location &_location = nostd::source_location::current() ) override;
 
     /**
      * @brief Output the log message.
@@ -95,11 +98,11 @@ namespace vx {
     /**
      * @brief Interval for reopening the log file.
      */
-    std::chrono::seconds m_reopenInterval;
+    std::chrono::seconds m_reopenInterval {};
 
     /**
      * @brief Timestamp of last reopen activity.
      */
-    std::chrono::system_clock::time_point m_lastReopen;
+    std::chrono::system_clock::time_point m_lastReopen {};
   };
 }

source/Logger.cpp

@@ -35,7 +35,9 @@ namespace vx {
 
   Logger::Logger( [[maybe_unused]] const std::unordered_map<std::string, std::string> &_configuration ) {}
 
-  void Logger::log( [[maybe_unused]] const std::string &_message, [[maybe_unused]] const Severity _severity ) { /* /dev/null logger */ }
+  void Logger::log( [[maybe_unused]] const std::string &_message,
+                    [[maybe_unused]] const Severity _severity,
+                    [[maybe_unused]] const nostd::source_location &_location ) { /* /dev/null logger */ }
 
   void Logger::log( [[maybe_unused]] const std::string &_message ) { /* /dev/null logger */ }
 }

source/Logger.h

@@ -33,6 +33,7 @@
 /* stl header */
 #include <chrono>
 #include <iomanip>
+#include <source_location.hpp>
 #include <sstream>
 #include <string>
 #include <unordered_map>
@@ -56,19 +57,19 @@ namespace vx {
   };
 
 #if defined(LOGGINGALL) || defined(LOGGINGVERBOSE)
-  constexpr Severity avoidLogAbove = Severity::Verbose;
+  constexpr Severity avoidLogBelow = Severity::Verbose;
 #elif defined(LOGGINGDEBUG)
-  constexpr Severity avoidLogAbove = Severity::Debug;
+  constexpr Severity avoidLogBelow = Severity::Debug;
 #elif defined(LOGGINGWARNING)
-  constexpr Severity avoidLogAbove = Severity::Warning;
+  constexpr Severity avoidLogBelow = Severity::Warning;
 #elif defined(LOGGINGERROR)
-  constexpr Severity avoidLogAbove = Severity::Error;
+  constexpr Severity avoidLogBelow = Severity::Error;
 #elif defined(LOGGINGFATAL)
-  constexpr Severity avoidLogAbove = Severity::Fatal;
+  constexpr Severity avoidLogBelow = Severity::Fatal;
 #elif defined(LOGGINGNONE)
-  constexpr Severity avoidLogAbove = Severity::Fatal + 1;
+  constexpr Severity avoidLogBelow = Severity::Fatal + 1;
 #else
-  constexpr Severity avoidLogAbove = Severity::Info;
+  constexpr Severity avoidLogBelow = Severity::Info;
 #endif
 
   /**
@@ -84,9 +85,9 @@ namespace vx {
     const auto nowMs = std::chrono::duration_cast<std::chrono::microseconds>( now.time_since_epoch() ) % 1000000;
 
 #ifdef _WIN32
-  localtime_s(&currentLocalTime, &nowAsTimeT);
+    localtime_s( &currentLocalTime, &nowAsTimeT );
 #else
-  localtime_r(&nowAsTimeT, &currentLocalTime);
+    localtime_r( &nowAsTimeT, &currentLocalTime );
 #endif
 
     std::ostringstream nowSs;
@@ -100,16 +101,6 @@ namespace vx {
     return result;
   }
 
-  // TODO: Currently not used
-/*  inline std::string threadId() {
-
-    std::ostringstream s;
-    s << " [" << std::this_thread::get_id() << "]";
-    s.flush();
-    std::string result = s.str();
-    return result;
-  } */
-
   /**
    * @brief The Logger class.
    * @note Not pure virtual to use as /dev/null logger.
@@ -138,8 +129,11 @@ namespace vx {
      * @brief Build the log message.
      * @param _message   Message to log.
      * @param _severity   Severity level of the message.
+     * @param _location   Source location information.
      */
-    virtual void log( const std::string &_message, const Severity _severity );
+    virtual void log( const std::string &_message,
+                      const Severity _severity,
+                      const nostd::source_location &_location = nostd::source_location::current() );
 
     /**
      * @brief Output the log message.

source/LoggerFactory.cpp

@@ -64,6 +64,6 @@ namespace vx {
     }
 
     /* couldn't get a logger */
-    throw std::invalid_argument( "Couldn't produce logger for type: " + type->second );
+    throw std::invalid_argument( "Couldn't produce logger of type: " + type->second );
   }
 }