mld/logging/Logger.hxx

Go to the documentation of this file.

// Copyright 2022 Siemens Digital Industries Software
// ==================================================
// Copyright 2011.
// Siemens Product Lifecycle Management Software Inc.
// All Rights Reserved.
// ==================================================
// Copyright 2022 Siemens Digital Industries Software
#ifndef TEAMCENTER_LOGGING_LOGGER_HXX
#define TEAMCENTER_LOGGING_LOGGER_HXX

#include <string>
#include <vector>
#include <cstdarg>
#include <string_view>
#include <common/tc_deprecation_macros.h>

#include <mld/libmld_exports.h>

// The string representation of the allowed appenders.
#define APPENDER_SYSLOG_STR     "syslog"
#define APPENDER_STDOUT_STR     "stdout" 
#define APPENDER_STDERR_STR     "stderr"

namespace Teamcenter
{
    namespace Logging
    {
        class MLD_API Logger
        {
            public:
                friend class LoggerTree;
                friend class Node;

                enum level{LOG_TRACE=1,LOG_DEBUG=2,LOG_INFO=3,LOG_WARN=4,LOG_ERROR=5,LOG_FATAL=6,LOG_NOTE=7,LOG_OFF=8};

                enum appender{APPENDER_SYSLOG=0, APPENDER_STDOUT=1, APPENDER_STDERR=2};

                std::string getLoggerName() const { return loggerName; };

                void setLogLevel(level lvl);
                level getLogLevel() const { return logLevel; };

                 bool isTraceEnabled() const { return ( LOG_TRACE >= logLevel ); };
                 bool isDebugEnabled() const { return ( LOG_DEBUG >= logLevel ); };

                 bool isInfoEnabled() const { return ( LOG_INFO >= logLevel ); };

                 bool isWarnEnabled() const { return ( LOG_WARN >= logLevel ); };

                 bool isErrorEnabled() const { return ( LOG_ERROR >= logLevel ); };

                 bool isFatalEnabled() const { return ( LOG_FATAL >= logLevel ); };

                 void fatal(const std::string &msg) { log(LOG_FATAL, msg); };

                 void fatal(const int errorCode, const std::string &msg) { log(LOG_FATAL, errorCode, msg); };

                 void fatal( const char* file, const int line, const int errorCode, const std::string &msg) { log(LOG_FATAL, file, line, errorCode, msg); };

                 void fatal( const char* file, const int line, const int errorCode, const char* control_string, ... );

                 void error(const std::string &msg) { log(LOG_ERROR, msg); };

                 void error(const int errorCode, const std::string &msg) { log(LOG_ERROR, errorCode, msg); };

                 void error( const char* file, const int line, const int errorCode, const std::string &msg) { log(LOG_ERROR, file, line, errorCode, msg); };
                 void error( const char* file, const int line, const int errorCode, const char* control_string, ... );

                 void warn(const std::string &msg) { log(LOG_WARN, msg); };

                 void warn(const int errorCode, const std::string &msg) { log(LOG_WARN, errorCode, msg); };

                 void warn ( const char* file, const int line, const int errorCode, const std::string &msg) { log(LOG_WARN, file, line, errorCode, msg); };

                 void warn( const char* file, const int line, const int errorCode, const char* control_string, ... );

                 void info(const std::string &msg) { log(LOG_INFO, msg); };

                 void info ( const char* file, const int line, const std::string &msg) { log(LOG_INFO, file, line, msg); };

                 void info ( const char* file, const int line, const int errorCode, const std::string &msg) { log(LOG_INFO, file, line, errorCode, msg); };

                 void info( const char* file, const int line, const char *control_string, ... );

                 void debug(const std::string &msg) { log(LOG_DEBUG, msg); };

                 void debug( const int errorCode, const std::string& msg ) { log( LOG_DEBUG, errorCode, msg ); };

                 void debug( const char* file, const int line, const std::string &msg) { log(LOG_DEBUG, file, line, msg); };

                 void debug ( const char* file, const int line, const int errorCode, const std::string &msg) { log(LOG_DEBUG, file, line, errorCode, msg); };

                 void debug( const char* file, const int line, const char* control_string, ... );

                 void debug( const char* file, const int line, const int errorCode, const char* control_string, ... );
                 void trace(const std::string &msg) { log(LOG_TRACE, msg); };

                 void trace( const char* file, const int line, const std::string &msg) { log(LOG_TRACE, file, line, msg); };

                 void trace ( const char* file, const int line, const int errorCode, const std::string &msg) { log(LOG_TRACE, file, line, errorCode, msg); };

                 void trace( const char* file, const int line, const char *control_string, ... );

                 TC_DEPRECATED_NO_REPLACEMENT( "11.4", "Teamcenter::Logging::Logger::note" )
                 void note(const std::string &msg) { log(LOG_NOTE, msg); };

                 TC_DEPRECATED_NO_REPLACEMENT( "11.4", "Teamcenter::Logging::Logger::note" )
                 void note( const char* file, const int line, const char *control_string, ... );

                 void log( const Logger::level lvl, const std::string& msg );

                 void log( const Logger::level lvl, const std::string errorCode, const std::string& msg );

                 void log( const Logger::level lvl, const int errorCode, const std::string& msg );

                 void log( const Logger::level lvl, const char* file, const int line, const int errorCode, const std::string& msg );

                 void log ( const Logger::level lvl, const char *file, const int line, const std::string& msg);

                 void logNoStackTrace ( const Logger::level lvl, const char *file, const int line, const int errorCode, const std::string &msg);

                 bool isEnabled (const Logger::level lvl) const { return ( lvl >= logLevel ); };
                 static Logger* getLogger(const std::string &key);

                void logf( const Logger::level lvl, const int errorCode, const char *control_string, ... ) ;

                void logf( const Logger::level lvl, const char *file, const int line, const int errorCode, const char *control_string, ... );

                void printf( const Logger::level lvl, const char *control_string, ... );

                void printf( const char *control_string, ... );

                void printString( std::string_view str ) const;

                static Logger* getLoggerObject(const std::string &key);

                // this method sets the given name to the logger.
                void setLoggerName(const std::string &name) { loggerName=name; };

                //Returns all the child loggers for a logger.
                static std::vector<Logger *> getListOfLoggers(std::string key);

                // returns the log level inheritance flag
                bool isLogLevelInherited () const { return logLevelInherited; };

                // sets the log level inheritance flag
                void setInheritanceLevel ( bool isInherited) { logLevelInherited = isInherited; };

                // set the logLevelInherited member variable
                // if set to true log level will be inherited from parent.
                // if set to false log level will not be inherited from parent.
                void setLogLevelInheritance (bool isInherited);

                void logAlways( const Logger::level lvl, int errorCode, std::string_view msg );

                void logAlways( const Logger::level lvl, const char* file, const int line, const int errorCode, std::string_view msg );

            private:

                // unique name for each logger.
                std::string loggerName;

                // logger level
                level logLevel;

                // We used a static data member to remember the choice of the appender, which is defined in the logger property file: logger.properties and logger.debug.properties
                // Please see documentation on environment variable 'UGII_CHECKING_LEVEL' on when each file is used for logging.
                // The syntax is as the following:
                //    logging.rootLogger={INFO|DEBUG|OFF}{,syslog|stderr|stdout}
                // If there is no appender specified, or if the value is invalid, 'syslog' will be the default appender. Currently we only support a single choice of appender defined inside the rootLogger.
                // For example:
                //          "logging.rootLogger=INFO,stdout"  will send output the the console window and not to the syslog.
                // All loggers will inherit the same appender as the rootLogger.
                // We may consider supporting any individual logger setting its own appender, and even allowing multiple appenders for a single loggers.
                static int appender;
                
                // flag to check whether log level is inherited from parent.
                bool  logLevelInherited;

                // Copy constructor and assignment operator are disabled and unimplemented
                // Since a Logger need not exist outside a LoggerTree
                Logger( const Logger& );
                Logger& operator=( const Logger& );

                explicit Logger(const std::string &name);

                Logger(const std::string &name, level lvl);

                std::string getTime() const;


                std::string formatLogEntry ( const Logger::level lvl, const std::string_view errCode ) const;
                std::string formatLogEntry ( const Logger::level lvl ) const;
                std::string formatLogEntry( const Logger::level lvl, const int errCode, bool includLoggerName ) const;

                FILE* getLogFilePointer() const;

                void writeToLogAndPublish( const std::string& str );


                bool isErrorSuppression(const Logger::level lvl, const int errorCode);

                void processErrorSuppressionAndLog( std::string& logLine );

                void appendFileAndLine(std::string &str, const char* file, const int line) const;

                ~Logger();

                Logger();

                void setLogLevelAttribute(level lvl) { logLevel = lvl; logLevelInherited = false; };

                std::string substituteForInvalidArgs ( const char* control_string, va_list ap1 );

                int checkForNullPointer ( const char* control_string, va_list ap1);

                void logv( const Logger::level lvl, const char* file, const int line, const int errorCode, const char* control_string, std::va_list va );

                void stackTrace( const Logger::level lvl );

                 void appendFileNameForCentralizedLogging(std::string &str) const;

                 static std::string getLeafName(std::string absolutePath );
        };
    }
}

#include <mld/libmld_undef.h>
#endif