vlogger.h

Go to the documentation of this file.

/*
Copyright c1997-2014 Trygve Isaacson. All rights reserved.
This file is part of the Code Vault version 4.1
http://www.bombaydigital.com/
License: MIT. See LICENSE.md in the Vault top level directory.
*/

#ifndef vlogger_h
#define vlogger_h

#include "vtypes.h"

#include "vmutex.h"
#include "vbufferedfilestream.h"
#include "vtextiostream.h"

// Microsoft steals this symbol name globally. Take it back.
#ifdef VPLATFORM_WIN
    #undef ERROR
#endif
// Xcode 5 steals this symbol name globally. Take it back.
#ifdef VPLATFORM_MAC
    #undef DEBUG
#endif

class VSettings;
class VSettingsNode;
class VBentoNode;

// This first set of macros sends output to the default logger.
#define VLOGGER_LEVEL(level, message) do { if (!VLogger::isDefaultLogLevelActive(level)) break; VLogger::getDefaultLogger()->log(level, NULL, 0, message, VString::EMPTY()); } while (false)
#define VLOGGER_LEVEL_FILELINE(level, message, file, line) do { if (!VLogger::isDefaultLogLevelActive(level)) break; VLogger::getDefaultLogger()->log(level, file, line, message, VString::EMPTY()); } while (false)
#define VLOGGER_LINE(level, message) VLOGGER_LEVEL_FILELINE(level, message, __FILE__, __LINE__)
#define VLOGGER_FATAL_AND_THROW(message) do { VLogger::getDefaultLogger()->log(VLoggerLevel::FATAL, __FILE__, __LINE__, message); throw VStackTraceException(message); } while (false)
#define VLOGGER_FATAL(message) VLOGGER_LEVEL_FILELINE(VLoggerLevel::FATAL, message, __FILE__, __LINE__)
#define VLOGGER_ERROR(message) VLOGGER_LEVEL_FILELINE(VLoggerLevel::ERROR, message, __FILE__, __LINE__)
#define VLOGGER_WARN(message) VLOGGER_LEVEL(VLoggerLevel::WARN, message)
#define VLOGGER_INFO(message) VLOGGER_LEVEL(VLoggerLevel::INFO, message)
#define VLOGGER_DEBUG(message) VLOGGER_LEVEL(VLoggerLevel::DEBUG, message)
#define VLOGGER_TRACE(message) VLOGGER_LEVEL(VLoggerLevel::TRACE, message)
#define VLOGGER_HEXDUMP(level, message, buffer, length) do { if (!VLogger::isDefaultLogLevelActive(level)) break; VLogger::getDefaultLogger()->logHexDump(level, message, VString::EMPTY(), buffer, length); } while (false)
#define VLOGGER_WOULD_LOG(level) (VLogger::isDefaultLogLevelActive(level))

// This set of macros sends output to a specified named logger.
#define VLOGGER_NAMED_LEVEL(loggername, level, message) do { if (!VLogger::isLogLevelActive(level)) break; VNamedLoggerPtr nl = VLogger::findNamedLoggerForLevel(loggername, level); if (nl != nullptr) nl->log(level, NULL, 0, message, loggername); } while (false)
#define VLOGGER_NAMED_LEVEL_FILELINE(loggername, level, message, file, line) do { if (!VLogger::isLogLevelActive(level)) break; VNamedLoggerPtr nl = VLogger::findNamedLoggerForLevel(loggername, level); if (nl != nullptr) nl->log(level, file, line, message, loggername); } while (false)
#define VLOGGER_NAMED_LINE(loggername, level, message) VLOGGER_NAMED_LEVEL_FILELINE(loggername, level, message, __FILE__, __LINE__)
#define VLOGGER_NAMED_FATAL(loggername, message) VLOGGER_NAMED_LEVEL_FILELINE(loggername, VLoggerLevel::FATAL, message, __FILE__, __LINE__)
#define VLOGGER_NAMED_ERROR(loggername, message) VLOGGER_NAMED_LEVEL_FILELINE(loggername, VLoggerLevel::ERROR, message, __FILE__, __LINE__)
#define VLOGGER_NAMED_WARN(loggername, message) VLOGGER_NAMED_LEVEL(loggername, VLoggerLevel::WARN, message)
#define VLOGGER_NAMED_INFO(loggername, message) VLOGGER_NAMED_LEVEL(loggername, VLoggerLevel::INFO, message)
#define VLOGGER_NAMED_DEBUG(loggername, message) VLOGGER_NAMED_LEVEL(loggername, VLoggerLevel::DEBUG, message)
#define VLOGGER_NAMED_TRACE(loggername, message) VLOGGER_NAMED_LEVEL(loggername, VLoggerLevel::TRACE, message)
#define VLOGGER_NAMED_HEXDUMP(loggername, level, message, buffer, length) do { if (!VLogger::isLogLevelActive(level)) break; VNamedLoggerPtr nl = VLogger::findNamedLoggerForLevel(loggername, level); if (nl != nullptr) nl->logHexDump(level, message, loggername, buffer, length); } while (false)
#define VLOGGER_NAMED_WOULD_LOG(loggername, level) (VLogger::isLogLevelActive(level) && (VLogger::findNamedLoggerForLevel(loggername, level) != nullptr))

#define VLOGGER_APPENDER_EMIT(appender, level, message) do { (appender).emit(level, (level <= VLoggerLevel::ERROR) ? __FILE__ : NULL, (level <= VLoggerLevel::ERROR) ? __LINE__ : 0, true, message, VString::EMPTY(), VString::EMPTY(), false, VString::EMPTY()); } while (false)
#define VLOGGER_APPENDER_EMIT_FILELINE(appender, level, message, file, line) do { (appender).emit(level, file, line, true, message, VString::EMPTY(), VString::EMPTY(), false, VString::EMPTY()); } while (false)

class VLogAppender {
    public:

        // These constants can be used for the formatOutput constructor parameter.
        static const bool DO_FORMAT_OUTPUT = true;
        static const bool DONT_FORMAT_OUTPUT = false;

        VLogAppender(const VString& name, bool formatOutput, const VString& formatSpec, const VString& timeFormat);
        VLogAppender(const VSettingsNode& settings, const VSettingsNode& defaults);

        virtual ~VLogAppender();

        const VString& getName() const { return mName; }    
        bool isDefaultAppender() const;                     

        virtual void emit(int level, const char* file, int line, bool emitMessage, const VString& message, const VString& specifiedLoggerName, const VString& actualLoggerName, bool emitRawLine, const VString& rawLine);
        void emitRaw(const VString& message);

        virtual void addInfo(VBentoNode& infoNode) const;

    protected:

        virtual void _emitMessage(int level, const char* file, int line, const VString& message, const VString& specifiedLoggerName, const VString& actualLoggerName);
        virtual VString _formatMessage(int level, const char* file, int line, const VString& message, const VString& specifiedLoggerName, const VString& actualLoggerName);
        virtual void _emitRawLine(const VString& /*line*/) {}

        // These helper functions are meant to be used by subclasses constructing from settings.
        // Such constructors usually need to get settings, and fall back first to configured defaults, then to a specific default value.
        static bool _getBooleanInitSetting(const VString& attributePath, const VSettingsNode& settings, const VSettingsNode& defaults, bool defaultValue);
        static int _getIntInitSetting(const VString& attributePath, const VSettingsNode& settings, const VSettingsNode& defaults, int defaultValue);
        static VString _getStringInitSetting(const VString& attributePath, const VSettingsNode& settings, const VSettingsNode& defaults, const VString& defaultValue);

        VMutex              mMutex;          
                                                // subclasses may access this carefully; note that it is locked prior to any
                                                // call to emitMessage() or emitRawLine(), so implementors of those functions must
                                                // not re-lock because to do so would cause a deadlock.
        VString             mName;          
        bool                mFormatOutput;  
        VString             mFormatSpec;    
        VInstantFormatter   mTimeFormatter; 
        
        // These fields cache state of the mFormatSpec. This allows _formatMessage() to avoid unnecessary work
        // when we know the format doesn't need everything to be supplied. If we allow mFormatSpec to be set
        // after construction, these will have to be re-calculated at that time.
        bool    mFormatUsesLocalTime;
        bool    mFormatUsesUTCTime;
        bool    mFormatUsesLevel;
        bool    mFormatUsesThread;
        bool    mFormatUsesLocation;
        bool    mFormatUsesSpecifiedLoggerName;
        bool    mFormatUsesActualLoggerName;

    private:

        VString _toString() const; 

        static void _breakpointLocationForEmit(); 
};

typedef VSharedPtr<VLogAppender> VLogAppenderPtr;
typedef VSharedPtr<const VLogAppender> VLogAppenderConstPtr;
typedef std::vector<VLogAppenderPtr> VLogAppenderPtrList;

class VNamedLogger;

class VLoggerRepetitionFilter {
    public:

        VLoggerRepetitionFilter();
        virtual ~VLoggerRepetitionFilter() {}

        void setEnabled(bool enabled) { mEnabled = enabled; }
        bool isEnabled() const { return mEnabled; }

        void reset();

        bool checkMessage(VNamedLogger& logger, int level, const char* file, int line, const VString& message, const VString& specifiedLoggerName, const VString& actualLoggerName);

        void checkTimeout(VNamedLogger& logger);

    private:

        VLoggerRepetitionFilter(const VLoggerRepetitionFilter&); // not copyable
        VLoggerRepetitionFilter& operator=(const VLoggerRepetitionFilter&); // not assignable

        void _emitSuppressedMessages(VNamedLogger& logger);

        bool        mEnabled; 

        // Information defining the saved output. The (level, file, line, message) combination
        // defines a repeated message. If any of those differ, then it's considered a different
        // message that is not a repeat.
        bool        mHasSavedMessage;           
        int         mNumSuppressedOccurrences;  
        VInstant    mTimeOfLastOccurrence;      
        int         mLevel;                     
        const char* mFile;                      
        int         mLine;                      
        VString     mMessage;                   
        VString     mSpecifiedLoggerName;       
        VString     mActualLoggerName;          
};

class VLoggerPrintStackConfig {
    public:

        VLoggerPrintStackConfig();
        ~VLoggerPrintStackConfig() {}

        int getLevel() const { return mLevel; } 
        void configure(int level, int maxNumOccurrences, const VDuration& timeLimit);
        bool shouldPrintStack(int level, VNamedLogger& logger);

    private:

        int         mLevel;         
        int         mMaxCount;      
        VDuration   mDuration;      
        int         mCountdown;     
        VInstant    mExpiration;    
};

class VNamedLogger : public VEnableSharedFromThis<VNamedLogger> {
    public:

        VNamedLogger(const VString& name, int level, const VStringVector& appenderNames, VLogAppenderPtr specificAppender = VLogAppenderPtr());
        virtual ~VNamedLogger();

        void clearAppenders();
        void setAppender(const VString& appenderName);
        void addAppender(const VString& appenderName);

        // The following log/emit APIs should generally be accessed through the VLOGGER macros.
        // However, it is legal to call them if you have a reference to a logger.

        void log(int level, const char* file, int line, const VString& message, const VString& specifiedLoggerName = VString::EMPTY());
        void log(int level, const VString& message);
        void logHexDump(int level, const VString& message, const VString& specifiedLoggerName, const Vu8* buffer, Vs64 length);
        void emitStackCrawlLine(const VString& message);

        const VString& getName() const { return mName; }            
        bool isEnabledFor(int level) { return level <= mLevel; }    
        int getLevel() const { return mLevel; }                     
        void setLevel(int level);                                   

        void setRepetitionFilterEnabled(bool enabled) { mRepetitionFilter.setEnabled(enabled); }    

        int getPrintStackLevel() const { return mPrintStackConfig.getLevel(); }
        void setPrintStackInfo(int printStackLevel, int maxNumOccurrences, const VDuration& timeLimit) { mPrintStackConfig.configure(printStackLevel, maxNumOccurrences, timeLimit); }
        bool isDefaultLogger() const;

        virtual void addInfo(VBentoNode& infoNode) const;

    protected:

        virtual void _emitToAppenders(int level, const char* file, int line, bool emitMessage, const VString& message, const VString& specifiedLoggerName, bool emitRawLine, const VString& rawLine);

    private:

        VString _toString() const; 

        static void _breakpointLocationForLog(); 

        VString                 mName;              
        int                     mLevel;             
        mutable VMutex          mAppendersMutex;    
        VStringVector           mAppenderNames;     
        VLogAppenderPtr         mSpecificAppender;  
        VLoggerRepetitionFilter mRepetitionFilter;  
        VLoggerPrintStackConfig mPrintStackConfig;  

        friend class VLoggerRepetitionFilter; // it can call our _emitToAppenders when we call it from our log() function
        friend class VLoggerPrintStackConfig; // ditto
};

typedef VSharedPtr<VNamedLogger> VNamedLoggerPtr;
typedef VSharedPtr<const VNamedLogger> VNamedLoggerConstPtr;

class VLogAppenderFactory {
    public:

        VLogAppenderFactory() {}
        virtual ~VLogAppenderFactory() {}

        virtual VLogAppenderPtr instantiateLogAppender(const VSettingsNode& settings, const VSettingsNode& defaults) const = 0;

        virtual void addInfo(VBentoNode& infoNode) const = 0;

};

typedef VSharedPtr<const VLogAppenderFactory> VLogAppenderFactoryPtr;

class VLoggerLevel {
    public:

        // Log level constants.
        static const int OFF   = 0;    
        static const int FATAL = 1;    
        static const int ERROR = 20;   
        static const int WARN  = 40;   
        static const int INFO  = 60;   
        static const int DEBUG = 80;   
        static const int TRACE = 100;  
        static const int ALL   = 100;  

        static VString getName(int level);
        static int fromString(const VString& value);
};

class VLogger {
    public:

        static void registerLogAppenderFactory(const VString& appenderKind, VLogAppenderFactoryPtr factory);

        static void configure(const VFSNode& baseLogDirectory, const VSettingsNode& loggingSettings);
        static void shutdown();

        static void installNewLogAppender(const VSettingsNode& appenderSettings, const VSettingsNode& appenderDefaults);
        static void installNewNamedLogger(const VSettingsNode& loggerSettings);
        static void installNewNamedLogger(const VString& name, int level, const VStringVector& appenderNames);
        static void installNewNamedLogger(const VString& name, int level, const VString& appenderName);
        static void registerLogAppender(VLogAppenderPtr appender, bool asDefaultAppender = false);
        static void registerGlobalAppender(VLogAppenderPtr appender, bool asDefaultAppender = false);
        static void registerLogger(VNamedLoggerPtr namedLogger, bool asDefaultLogger = false);
        static void deregisterLogAppender(VLogAppenderPtr appender);
        static void deregisterLogAppender(const VString& name);
        static void deregisterLogger(VNamedLoggerPtr namedLogger);
        static void deregisterLogger(const VString& name);
        static void checkMaxActiveLogLevelForRemovedLogger(int removedActiveLevel);
        static void checkMaxActiveLogLevelForChangedLogger(int oldActiveLevel, int newActiveLevel);

        static bool isDefaultLogLevelActive(int level);
        static bool isLogLevelActive(int level);

        // The following "getters" and "finders" have the following consistent naming convention:
        // - "get" always returns a valid object; it may need to create the object in question
        // - "find" will return null if there is no such object; it will not create an object

        // Loggers:
        static VNamedLoggerPtr getDefaultLogger();
        static void setDefaultLogger(VNamedLoggerPtr namedLogger);
        static VNamedLoggerPtr getLogger(const VString& name);
        static VNamedLoggerPtr findDefaultLogger();
        static VNamedLoggerPtr findDefaultLoggerForLevel(int level);
        static VNamedLoggerPtr findNamedLogger(const VString& name);
        static VNamedLoggerPtr findNamedLoggerForLevel(const VString& name, int level);

        // Appenders:
        static VLogAppenderPtr getDefaultAppender();
        static VLogAppenderPtr getAppender(const VString& appenderName);
        static VLogAppenderPtrList getAllAppenders();
        static VLogAppenderPtr findDefaultAppender();
        static VLogAppenderPtr findAppender(const VString& name);
        static const VFSNode& getBaseLogDirectory();

        // These functions whose name is prefixed with "command" are intended for use at runtime from
        // a command facility that allows reconfiguring logging on the fly.
        static VBentoNode* commandGetInfo();    
        static VString commandGetInfoString();  
        static void commandNewAppender(const VString& appenderName, const VString& kind, const VString& appenderParam); 
        static void commandRemoveAppender(const VString& appenderName);                                                 
        static void commandRollAppender(const VString& appenderName);                                                   
        static void commandNewLogger(const VString& loggerName, const VStringVector& appenderNames);                    
        static void commandRemoveLogger(const VString& loggerName);                                                     
        static void commandSetLoggerAppenders(const VString& loggerName, const VStringVector& appenderNames);           
        static void commandAddLoggerAppenders(const VString& loggerName, const VStringVector& appenderNames);           
        static void commandRemoveLoggerAppenders(const VString& loggerName, const VStringVector& appenderNames);        
        static void commandSetLogLevel(const VString& loggerName, int level);                                           
        static void commandSetPrintStackLevel(const VString& loggerName, int printStackLevel, int count, const VDuration& timeLimit); 

        // Used specifically by VNamedLogger::_emitToAppenders to emit to all "global appenders" with correct locking. Should not be called elsewhere.
        static void emitToGlobalAppenders(int level, const char* file, int line, bool emitMessage, const VString& message, const VString& specifiedLoggerName, const VString& actualLoggerName, bool emitRawLine, const VString& rawLine);
        
        // Utility function useful in forming a logger name; returns a copy of the input string with dots (our path separators) converted to dashes.
        static VString getCleansedLoggerName(const VString& s);

    private:

        VLogger(const VLogger&); // not copyable
        VLogger& operator=(const VLogger&); // not assignable

        // These helper methods, like private methods in general, assume the caller has locked.
        static void _registerAppender(VLogAppenderPtr appender, bool asDefaultAppender = false, bool asGlobalAppender = false);
        static void _registerLogger(VNamedLoggerPtr namedLogger, bool asDefaultLogger = false);
        static VBentoNode* _commandGetInfo();
        static VString _commandGetInfoString();

        // These methods maintain the gMaxActiveLogLevel.
        static void _checkMaxActiveLogLevelForNewLogger(int newActiveLevel); // Called when a new logger is created, since that may change the max active log level.
        static void _checkMaxActiveLogLevelForRemovedLogger(int removedActiveLevel); // Called when a logger is removed, since that may change the max active log level.
        static void _checkMaxActiveLogLevelForChangedLogger(int oldActiveLevel, int newActiveLevel); // Called when a logger's level is changed, since that may change the max active log level.
        static void _recalculateMaxActiveLogLevel(); // Called when one of the _check... methods decides the max active log level may indeed have changed, and must be recalculated.

        // These two methods are how we really search for a specified named logger.
        static VNamedLoggerPtr _findNamedLoggerFromExactName(const VString& name);      
        static VNamedLoggerPtr _findNamedLoggerFromPathName(const VString& pathName);   

        // _mutexInstance() must be used internally whenever referencing these variables:
        volatile static int     gMaxActiveLevel;    
        static VNamedLoggerPtr  gDefaultLogger;     
        static VLogAppenderPtr  gDefaultAppender;   
        static VFSNode          gBaseLogDirectory;  

        friend class VLoggerUnit;  // unit tests directly examine our state
        friend bool VNamedLogger::isDefaultLogger() const;
        friend bool VLogAppender::isDefaultAppender() const;

        // Internal development debugging methods. Only enabled as needed.
//#define VLOGGER_INTERNAL_DEBUGGING
#ifdef VLOGGER_INTERNAL_DEBUGGING
        static void _reportLoggerChange(bool before, const VString& label, const VNamedLoggerPtr& was, const VNamedLoggerPtr& is);
        static void _reportAppenderChange(bool before, const VString& label, const VLogAppenderPtr& was, const VLogAppenderPtr& is);
#else
        static void _reportLoggerChange(bool /*before*/, const VString& /*label*/, const VNamedLoggerPtr& /*was*/, const VNamedLoggerPtr& /*is*/) {}
        static void _reportAppenderChange(bool /*before*/, const VString& /*label*/, const VLogAppenderPtr& /*was*/, const VLogAppenderPtr& /*is*/) {}
#endif /* VLOGGER_INTERNAL_DEBUGGING */
};

class VCoutLogAppender : public VLogAppender {
    public:
        VCoutLogAppender(const VString& name, bool formatOutput, const VString& formatSpec, const VString& timeFormat);
        VCoutLogAppender(const VSettingsNode& settings, const VSettingsNode& defaults);
        virtual ~VCoutLogAppender() {}
        virtual void addInfo(VBentoNode& infoNode) const;
    protected:
        virtual void _emitRawLine(const VString& line);
};

class VFileLogAppender : public VLogAppender {
    public:
        VFileLogAppender(const VString& name, bool formatOutput, const VString& formatSpec, const VString& timeFormat, const VString& filePath);
        VFileLogAppender(const VSettingsNode& settings, const VSettingsNode& defaults);
        virtual ~VFileLogAppender() {}
        virtual void addInfo(VBentoNode& infoNode) const;
    protected:
        virtual void _emitRawLine(const VString& line);
    private:
        void _openFile(); // constructor helper
        VBufferedFileStream mFileStream;    
        VTextIOStream       mOutputStream;  
};

class VRollingFileLogAppender : public VLogAppender {
    public:
        VRollingFileLogAppender(const VString& name, bool formatOutput, const VString& formatSpec, const VString& timeFormat, const VString& dirPath, const VString& fileNamePrefix, int maxNumLines);
        VRollingFileLogAppender(const VSettingsNode& settings, const VSettingsNode& defaults);
        virtual ~VRollingFileLogAppender() {}
        virtual void addInfo(VBentoNode& infoNode) const;
    protected:
        virtual void _emitRawLine(const VString& line);
};

class VSilentLogAppender : public VLogAppender {
    public:
        VSilentLogAppender(const VString& name) : VLogAppender(name, true/*this won't matter*/, VString::EMPTY(), VString::EMPTY()) {}
        VSilentLogAppender(const VSettingsNode& settings, const VSettingsNode& defaults) : VLogAppender(settings, defaults) {}
        virtual ~VSilentLogAppender() {}
        virtual void addInfo(VBentoNode& infoNode) const;
        virtual void emit(int /*level*/, const char* /*file*/, int /*line*/, bool /*emitMessage*/, const VString& /*message*/, bool /*emitRawLine*/, const VString& /*rawLine*/) {}
};

class VStringLogAppender : public VLogAppender {
    public:
        VStringLogAppender(const VString& name, bool formatOutput, const VString& formatSpec, const VString& timeFormat);
        VStringLogAppender(const VSettingsNode& settings, const VSettingsNode& defaults);
        virtual ~VStringLogAppender() {}
        virtual void addInfo(VBentoNode& infoNode) const;

        VMutex& getMutex() { return mMutex; }
        const VString& getLines() const { return mLines; }
        const char* orphanLines() { return mLines.orphanDataBuffer(); }

    protected:
        virtual void _emitRawLine(const VString& line);
    private:
        VString mLines;
};

class VStringVectorLogAppender : public VLogAppender {
    public:
        VStringVectorLogAppender(const VString& name, bool formatOutput, const VString& formatSpec, const VString& timeFormat, VStringVector* storage);
        VStringVectorLogAppender(const VSettingsNode& settings, const VSettingsNode& defaults);
        virtual ~VStringVectorLogAppender();
        virtual void addInfo(VBentoNode& infoNode) const;

        VMutex& getMutex() { return mMutex; }
        const VStringVector& getLines() const { return *mStorage; }

    protected:
        virtual void _emitRawLine(const VString& line);
    private:
        VStringVector* mStorage;
        VStringVector mLines;
};

class VStringLogger : public VNamedLogger {
    public:

        VStringLogger(const VString& name, int level, bool formatOutput = VLogAppender::DO_FORMAT_OUTPUT, const VString& formatSpec = VString::EMPTY(), const VString& timeFormat = VString::EMPTY());
        virtual ~VStringLogger() {}
        virtual void addInfo(VBentoNode& infoNode) const;

        const VString& getLines() const { return mAppender.getLines(); }
        const char* orphanLines() { return mAppender.orphanLines(); }

    protected:

        virtual void _emitToAppenders(int level, const char* file, int line, bool emitMessage, const VString& message, const VString& specifiedLoggerName, bool emitRawLine, const VString& rawLine);

    private:

        VStringLogAppender mAppender;

};

typedef VSharedPtr<VStringLogger> VStringLoggerPtr;
typedef VSharedPtr<const VStringLogger> VStringLoggerConstPtr;

class VStringVectorLogger : public VNamedLogger {
    public:

        VStringVectorLogger(const VString& name, int level, VStringVector* storage, bool formatOutput = VLogAppender::DO_FORMAT_OUTPUT, const VString& formatSpec = VString::EMPTY(), const VString& timeFormat = VString::EMPTY());
        virtual ~VStringVectorLogger() {}
        virtual void addInfo(VBentoNode& infoNode) const;

        const VStringVector& getLines() const { return mAppender.getLines(); }

    protected:

        virtual void _emitToAppenders(int level, const char* file, int line, bool emitMessage, const VString& message, const VString& specifiedLoggerName, bool emitRawLine, const VString& rawLine);

    private:

        VStringVectorLogAppender mAppender;

};

typedef VSharedPtr<VStringVectorLogger> VStringVectorLoggerPtr;
typedef VSharedPtr<const VStringVectorLogger> VStringVectorLoggerConstPtr;

#endif /* vlogger_h */