Logger.hpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:7k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #ifndef Logger_H
  14. #define Logger_H
  15. #include <ndb_global.h>
  16. #include <BaseString.hpp>
  17. #define MAX_LOG_MESSAGE_SIZE 1024
  18. class LogHandler;
  19. class LogHandlerList;
  20. /**
  21.  * Logger should be used whenver you need to log a message like
  22.  * general information or debug messages. By creating/adding different
  23.  * log handlers, a single log message can be sent to 
  24.  * different outputs (stdout, file or syslog).
  25.  * 
  26.  * Each log entry is created with a log level (or severity) which is 
  27.  * used to identity the type of the entry, e.g., if it is a debug 
  28.  * or an error message.
  29.  * 
  30.  * Example of a log entry:
  31.  *
  32.  *  09:17:39 2002-03-13 [myLogger] INFO -- Local checkpoint started.
  33.  *
  34.  * HOW TO USE
  35.  *
  36.  * 1) Create a new instance of the Logger.
  37.  *
  38.  *    Logger myLogger = new Logger();
  39.  *
  40.  * 2) Add the log handlers that you want, i.e., where the log entries 
  41.  *    should be written/shown.
  42.  *
  43.  *    myLogger->createConsoleHandler();  // Output to console/stdout
  44.  *    myLogger->addHandler(new FileLogHandler("mylog.txt")); // use mylog.txt
  45.  *
  46.  *  3) Tag each log entry with a category/name.
  47.  *
  48.  *    myLogger->setCategory("myLogger");
  49.  *
  50.  * 4) Start log messages.
  51.  *    
  52.  *     myLogger->alert("T-9 to lift off");
  53.  *     myLogger->info("Here comes the sun, la la"); 
  54.  *     myLogger->debug("Why does this not work!!!, We should not be here...")
  55.  *
  56.  * 5) Log only debug messages.
  57.  *
  58.  *    myLogger->enable(Logger::LL_DEBUG);
  59.  *
  60.  * 6) Log only ALERTS and ERRORS.
  61.  *
  62.  *    myLogger->enable(Logger::LL_ERROR, Logger::LL_ALERT);
  63.  * 
  64.  * 7) Do not log any messages.
  65.  *
  66.  *    myLogger->disable(Logger::LL_ALL);
  67.  *
  68.  *
  69.  * LOG LEVELS (Matches the severity levels of syslog)
  70.  * <pre>
  71.  *
  72.  *  ALERT           A condition  that  should  be  corrected
  73.  *                  immediately,  such as a corrupted system
  74.  *                  database.
  75.  *
  76.  *  CRITICAL        Critical conditions, such as hard device
  77.  *                  errors.
  78.  *
  79.  *  ERROR           Errors.
  80.  *
  81.  *  WARNING         Warning messages.
  82.  *
  83.  *  INFO            Informational messages.
  84.  *
  85.  *  DEBUG           Messages that contain  information  nor-
  86.  *                  mally  of use only when debugging a pro-
  87.  *                  gram.
  88.  * </pre>
  89.  *
  90.  * @version #@ $Id: Logger.hpp,v 1.7 2003/09/01 10:15:53 innpeno Exp $
  91.  */
  92. class Logger
  93. {
  94. public:
  95.   /** The log levels. NOTE: Could not use the name LogLevel since 
  96.    * it caused conflicts with another class.
  97.    */
  98.   enum LoggerLevel {LL_ON, LL_DEBUG, LL_INFO, LL_WARNING, LL_ERROR,
  99.     LL_CRITICAL, LL_ALERT, LL_ALL};
  100.   
  101.   /**
  102.    * String representation of the the log levels.
  103.    */
  104.   static const char* LoggerLevelNames[];
  105.   /**
  106.    * Default constructor.
  107.    */
  108.   Logger();
  109.   /**
  110.    * Destructor.
  111.    */
  112.   virtual ~Logger();
  113.   
  114.   /**
  115.    * Set a category/name that each log entry will have.
  116.    *
  117.    * @param pCategory the category.
  118.    */
  119.   void setCategory(const char* pCategory);
  120.   /**
  121.    * Create a default handler that logs to the console/stdout.
  122.    *
  123.    * @return true if successful.
  124.    */
  125.   bool createConsoleHandler();
  126.   /**
  127.    * Remove the default console handler.
  128.    */
  129.   void removeConsoleHandler();
  130.   /**
  131.    * Create a default handler that logs to a file called logger.log.
  132.    *
  133.    * @return true if successful.
  134.    */
  135.   bool createFileHandler();
  136.   /**
  137.    * Remove the default file handler.
  138.    */
  139.   void removeFileHandler();
  140.   /**
  141.    * Create a default handler that logs to the syslog.
  142.    *
  143.    * On OSE a ConsoleHandler will be created since there is no syslog support.
  144.    *
  145.    * @return true if successful.
  146.    */
  147.   bool createSyslogHandler();
  148.   /**
  149.    * Remove the default syslog handler.
  150.    */
  151.   void removeSyslogHandler();
  152.   /**
  153.    * Add a new log handler.
  154.    *
  155.    * @param pHandler a log handler.
  156.    * @return true if successful.
  157.    */
  158.   bool addHandler(LogHandler* pHandler);
  159.   /**
  160.    * Add a new handler
  161.    *
  162.    * @param logstring string describing the handler to add
  163.    */
  164.   bool addHandler(const BaseString &logstring);
  165.   /**
  166.    * Remove a log handler.
  167.    *
  168.    * @param pHandler log handler to remove.
  169.    * @return true if successful.
  170.    */
  171.   bool removeHandler(LogHandler* pHandler);
  172.   /**
  173.    * Remove all log handlers.
  174.    */
  175.   void removeAllHandlers();
  176.   /**
  177.    * Returns true if the specified log level is enabled.
  178.    *
  179.    * @return true if enabled.
  180.    */
  181.   bool isEnable(LoggerLevel logLevel) const; 
  182.   /**
  183.    * Enable the specified log level.
  184.    *
  185.    * @param logLevel the loglevel to enable.
  186.    */
  187.   void enable(LoggerLevel logLevel);
  188.   /**
  189.    * Enable log levels.
  190.    *
  191.    * @param fromLogLevel enable from log level.
  192.    * @param toLogLevel enable to log level.
  193.    */
  194.   void enable (LoggerLevel fromLogLevel, LoggerLevel toLogLevel);
  195.   /**
  196.    * Disable log level.
  197.    *
  198.    * @param logLevel disable log level.
  199.    */
  200.   void disable(LoggerLevel logLevel);
  201.   /**
  202.    * Log an alert message.
  203.    *
  204.    * @param pMsg the message.
  205.    */
  206.   virtual void alert(const char* pMsg, ...) const;
  207.   virtual void alert(BaseString &pMsg) const { alert(pMsg.c_str()); };
  208.   
  209.   /**
  210.    * Log a critical message.
  211.    *
  212.    * @param pMsg the message.
  213.    */
  214.   virtual void critical(const char* pMsg, ...) const;
  215.   virtual void critical(BaseString &pMsg) const { critical(pMsg.c_str()); };
  216.   /**
  217.    * Log an error message.
  218.    *
  219.    * @param pMsg the message.
  220.    */
  221.   virtual void error(const char* pMsg, ...) const;
  222.   virtual void error(BaseString &pMsg) const { error(pMsg.c_str()); };
  223.   /**
  224.    * Log a warning message.
  225.    *
  226.    * @param pMsg the message.
  227.    */
  228.   virtual void warning(const char* pMsg, ...) const;
  229.   virtual void warning(BaseString &pMsg) const { warning(pMsg.c_str()); };
  230.   /**
  231.    * Log an info message.
  232.    *
  233.    * @param pMsg the message.
  234.    */
  235.   virtual void info(const char* pMsg, ...) const;
  236.   virtual void info(BaseString &pMsg) const { info(pMsg.c_str()); };
  237.   /**
  238.    * Log a debug message.
  239.    *
  240.    * @param pMsg the message.
  241.    */
  242.   virtual void debug(const char* pMsg, ...) const;
  243.   virtual void debug(BaseString &pMsg) const { debug(pMsg.c_str()); };
  244. protected:
  245.   void log(LoggerLevel logLevel, const char* msg, va_list ap) const;
  246. private:
  247.   /** Prohibit */
  248.   Logger(const Logger&);
  249.   Logger operator = (const Logger&);
  250.   bool operator == (const Logger&);
  251.   STATIC_CONST( MAX_LOG_LEVELS = 8 );
  252.   bool m_logLevels[MAX_LOG_LEVELS];
  253.   
  254.   LogHandlerList* m_pHandlerList;
  255.   const char* m_pCategory;
  256.   /* Default handlers */
  257.   LogHandler* m_pConsoleHandler;
  258.   LogHandler* m_pFileHandler;
  259.   LogHandler* m_pSyslogHandler;
  260. };
  261. #endif