release/src/router/mysql/storage/ndb/include/logger/Logger.hpp

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