Logger.h

Go to the documentation of this file.

#pragma once
 
#include <cstdio>
#include <cstdint>
#include <memory>
#include <array>
#include <mutex>
#include <ostream>
#include <sstream>
#include "DeprecationUtils.h"
#include "ObjectPool.h"
 
#ifndef LOG_MODULE
#   define LOG_MODULE UndefinedLogModule
#endif
 
// Use __FILE_NAME__ to avoid leaking complete full path
#ifdef __FILE_NAME__
#   define PCAPPP_FILENAME __FILE_NAME__
#else
#   define PCAPPP_FILENAME __FILE__
#endif
 
 
// Compile time log levels.
// Allows for conditional removal of unwanted log calls at compile time.
#define PCPP_LOG_LEVEL_OFF 0
#define PCPP_LOG_LEVEL_ERROR 1
#define PCPP_LOG_LEVEL_INFO 2
#define PCPP_LOG_LEVEL_DEBUG 3
 
// All log messages built via a PCPP_LOG_* macro below the PCPP_ACTIVE_LOG_LEVEL will be removed at compile time.
// Uses the PCPP_ACTIVE_LOG_LEVEL if it is defined, otherwise defaults to PCAP_LOG_LEVEL_DEBUG
#ifndef PCPP_ACTIVE_LOG_LEVEL
#   define PCPP_ACTIVE_LOG_LEVEL PCPP_LOG_LEVEL_DEBUG
#endif  // !PCPP_ACTIVE_LOG_LEVEL
 
namespace pcpp
{
    std::string getErrorString(int errnum);
 
    enum LogModule : uint8_t
    {
        UndefinedLogModule,
        CommonLogModuleIpUtils,          
        CommonLogModuleTablePrinter,     
        CommonLogModuleGenericUtils,     
        PacketLogModuleRawPacket,        
        PacketLogModulePacket,           
        PacketLogModuleLayer,            
        PacketLogModuleAsn1Codec,        
        PacketLogModuleArpLayer,         
        PacketLogModuleEthLayer,         
        PacketLogModuleIPv4Layer,        
        PacketLogModuleIPv6Layer,        
        PacketLogModulePayloadLayer,     
        PacketLogModuleTcpLayer,         
        PacketLogModuleUdpLayer,         
        PacketLogModuleVlanLayer,        
        PacketLogModuleHttpLayer,        
        PacketLogModulePPPoELayer,       
        PacketLogModuleDnsLayer,         
        PacketLogModuleMplsLayer,        
        PacketLogModuleIcmpLayer,        
        PacketLogModuleIcmpV6Layer,      
        PacketLogModuleGreLayer,         
        PacketLogModuleSSLLayer,         
        PacketLogModuleSllLayer,         
        PacketLogModuleSll2Layer,        
        PacketLogModuleNflogLayer,       
        PacketLogModuleDhcpLayer,        
        PacketLogModuleDhcpV6Layer,      
        PacketLogModuleIgmpLayer,        
        PacketLogModuleSipLayer,         
        PacketLogModuleSdpLayer,         
        PacketLogModuleRadiusLayer,      
        PacketLogModuleGtpLayer,         
        PacketLogModuleBgpLayer,         
        PacketLogModuleSSHLayer,         
        PacketLogModuleVrrpLayer,        
        PacketLogModuleTcpReassembly,    
        PacketLogModuleIPReassembly,     
        PacketLogModuleIPSecLayer,       
        PacketLogModuleNtpLayer,         
        PacketLogModuleTelnetLayer,      
        PacketLogModuleStpLayer,         
        PacketLogModuleLLCLayer,         
        PacketLogModuleNdpLayer,         
        PacketLogModuleFtpLayer,         
        PacketLogModuleSomeIpLayer,      
        PacketLogModuleSomeIpSdLayer,    
        PacketLogModuleWakeOnLanLayer,   
        PacketLogModuleSmtpLayer,        
        PacketLogModuleWireGuardLayer,   
        PcapLogModuleWinPcapLiveDevice,  
        PcapLogModuleRemoteDevice,       
        PcapLogModuleLiveDevice,         
        PcapLogModuleFileDevice,         
        PcapLogModulePfRingDevice,       
        PcapLogModuleMBufRawPacket,      
        PcapLogModuleDpdkDevice,         
        PcapLogModuleKniDevice,          
        PcapLogModuleXdpDevice,          
        PcapLogModuleNetworkUtils,       
        NumOfLogModules
    };
 
    struct LogSource
    {
        constexpr LogSource() = default;
 
        explicit constexpr LogSource(LogModule logModule) : logModule(logModule)
        {}
 
        constexpr LogSource(LogModule logModule, const char* file, const char* function, int line)
            : file(file), function(function), line(line), logModule(logModule)
        {}
 
        const char* file = nullptr;               
        const char* function = nullptr;           
        int line = 0;                             
        LogModule logModule = UndefinedLogModule; 
    };
 
    enum class LogLevel
    {
        Off = PCPP_LOG_LEVEL_OFF,      
        Error = PCPP_LOG_LEVEL_ERROR,  
        Info = PCPP_LOG_LEVEL_INFO,    
        Debug = PCPP_LOG_LEVEL_DEBUG   
    };
 
    inline std::ostream& operator<<(std::ostream& s, LogLevel v)
    {
        return s << static_cast<std::underlying_type<LogLevel>::type>(v);
    }
 
    // Forward declaration
    class Logger;
 
    namespace internal
    {
        class LogContext
        {
        public:
            friend class pcpp::Logger;
 
            LogContext() = default;
 
            explicit LogContext(LogLevel level, LogSource const& source = {}) : m_Source(source), m_Level(level)
            {}
 
            void init(LogLevel level, LogSource const& source)
            {
                m_Source = source;
                m_Level = level;
                m_Stream.clear();
                m_Stream.str({});
            }
 
            template <class T> inline LogContext& operator<<(T const& value)
            {
                m_Stream << value;
                return *this;
            }
 
        private:
            std::ostringstream m_Stream;
            LogSource m_Source;
            LogLevel m_Level = LogLevel::Info;
        };
    }  // namespace internal
 
    class Logger
    {
    public:
        Logger(const Logger&) = delete;
        Logger& operator=(const Logger&) = delete;
 
        // Deprecated, Use the LogLevel in the pcpp namespace instead.
        using LogLevel = pcpp::LogLevel;
        PCPP_DEPRECATED("Use the LogLevel in the pcpp namespace instead.")
        static const LogLevel Error = LogLevel::Error;
        PCPP_DEPRECATED("Use the LogLevel in the pcpp namespace instead.")
        static const LogLevel Info = LogLevel::Info;
        PCPP_DEPRECATED("Use the LogLevel in the pcpp namespace instead.")
        static const LogLevel Debug = LogLevel::Debug;
 
        using LogPrinter =
            std::add_pointer<void(LogLevel logLevel, const std::string& logMessage, const std::string& file,
                                  const std::string& method, const int line)>::type;
 
        static std::string logLevelAsString(LogLevel logLevel);
 
        LogLevel getLogLevel(LogModule module)
        {
            return m_LogModulesArray[module];
        }
 
        void setLogLevel(LogModule module, LogLevel level)
        {
            m_LogModulesArray[module] = level;
        }
 
        bool isDebugEnabled(LogModule module) const
        {
            return m_LogModulesArray[module] == LogLevel::Debug;
        }
 
        bool shouldLog(LogLevel level, LogModule module) const
        {
            return level != LogLevel::Off && m_LogModulesArray[module] >= level;
        }
 
        void setAllModulesToLogLevel(LogLevel level)
        {
            for (int i = 1; i < NumOfLogModules; i++)
            {
                m_LogModulesArray[i] = level;
            }
        }
 
        void setLogPrinter(LogPrinter printer)
        {
            m_LogPrinter = printer;
        }
 
        void resetLogPrinter()
        {
            m_LogPrinter = &defaultLogPrinter;
        }
 
        std::string getLastError() const
        {
            std::lock_guard<std::mutex> lock(m_LastErrorMtx);
            return m_LastError;
        }
 
        void suppressLogs()
        {
            m_LogsEnabled = false;
        }
 
        void enableLogs()
        {
            m_LogsEnabled = true;
        }
 
        bool logsEnabled() const
        {
            return m_LogsEnabled;
        }
 
        void useContextPooling(bool enabled, std::size_t preallocate = 2, std::size_t maxPoolSize = 10)
        {
            m_UseContextPooling = enabled;
 
            if (m_UseContextPooling)
            {
                m_LogContextPool.setMaxSize(maxPoolSize);
 
                if (preallocate > 0)
                {
                    m_LogContextPool.preallocate(preallocate);
                }
            }
            else
            {
                // Clear the pool if we're disabling pooling.
                m_LogContextPool.clear();
            }
        }
 
        static Logger& getInstance()
        {
            static Logger instance;
            return instance;
        }
 
        std::unique_ptr<internal::LogContext> createLogContext();
 
        std::unique_ptr<internal::LogContext> createLogContext(LogLevel level, LogSource const& source = {});
 
        void emit(LogSource const& source, LogLevel level, std::string const& message);
 
        void emit(std::unique_ptr<internal::LogContext> message);
 
    private:
        bool m_LogsEnabled;
        std::array<LogLevel, NumOfLogModules> m_LogModulesArray;
        LogPrinter m_LogPrinter;
 
        mutable std::mutex m_LastErrorMtx;
        std::string m_LastError;
 
        bool m_UseContextPooling = true;
        // Keep a maximum of 10 LogContext objects in the pool.
        internal::DynamicObjectPool<internal::LogContext> m_LogContextPool{ 10, 2 };
 
        // private c'tor - this class is a singleton
        Logger();
 
        static void defaultLogPrinter(LogLevel logLevel, const std::string& logMessage, const std::string& file,
                                      const std::string& method, int line);
    };
 
}  // namespace pcpp
 
#define PCPP_LOG(level, message)                                                                                       \
    do                                                                                                                 \
    {                                                                                                                  \
        auto& logger = pcpp::Logger::getInstance();                                                                    \
        if (logger.shouldLog(level, LOG_MODULE))                                                                       \
        {                                                                                                              \
            auto ctx =                                                                                                 \
                logger.createLogContext(level, pcpp::LogSource(LOG_MODULE, PCAPPP_FILENAME, __FUNCTION__, __LINE__));  \
            (*ctx) << message;                                                                                         \
            logger.emit(std::move(ctx));                                                                               \
        }                                                                                                              \
    } while (0)
 
#if PCPP_ACTIVE_LOG_LEVEL >= PCPP_LOG_LEVEL_DEBUG
#   define PCPP_LOG_DEBUG(message) PCPP_LOG(pcpp::LogLevel::Debug, message)
#else
#   define PCPP_LOG_DEBUG(message) (void)0
#endif
 
#if PCPP_ACTIVE_LOG_LEVEL >= PCPP_LOG_LEVEL_INFO
#   define PCPP_LOG_INFO(message) PCPP_LOG(pcpp::LogLevel::Info, message)
#else
#   define PCPP_LOG_INFO(message) (void)0
#endif
 
#if PCPP_ACTIVE_LOG_LEVEL >= PCPP_LOG_LEVEL_ERROR
#   define PCPP_LOG_ERROR(message) PCPP_LOG(pcpp::LogLevel::Error, message)
#else
#   define PCPP_LOG_ERROR(message) (void)0
#endif