H:/gfcppsancout/product/include/gfcpp/Log.hpp

Go to the documentation of this file.

#ifndef _GEMFIRE_LOG_HPP_
#define _GEMFIRE_LOG_HPP_


/*=========================================================================
 * (c) Copyright 2004-2007, GemStone Systems, Inc. All Rights Reserved.
 * 1260 NW Waterhouse Ave., Suite 200,  Beaverton, OR 97006
 *=========================================================================
 */

#include "gfcpp_globals.hpp"
#include <stdio.h>
#include <stdarg.h>

/******************************************************************************/


#ifndef GEMFIRE_HIGHEST_LOG_LEVEL
  #define GEMFIRE_HIGHEST_LOG_LEVEL             All
#endif


#ifndef GEMFIRE_MAX_LOG_FILE_LIMIT
  #define GEMFIRE_MAX_LOG_FILE_LIMIT            (1024 * 1024 * 1024)
#endif

#ifndef GEMFIRE_MAX_LOG_DISK_LIMIT
#define GEMFIRE_MAX_LOG_DISK_LIMIT              (1024ll * 1024ll * 1024ll * 1024ll)
#endif

#define _GF_MSG_LIMIT                           8192

/******************************************************************************/

namespace gemfire {

class Exception;

/******************************************************************************/
/******************************************************************************/

/* Logs the message if the given level is less than or equal to the current logging level. */
#define GF_LOG(level,expr) if ( level > gemfire::Log::logLevel() ) { } else gemfire::Log::log(level, expr)



class CPPCACHE_EXPORT Log {

public:


  /******/


  enum LogLevel {

    // NOTE: if you change this enum declaration at all, be sure to
    // change levelToChars and charsToLevel functions!

    None,

    Error,
    Warning,
    Info,

    Default,

    Config,

    Fine,
    Finer,
    Finest,

    Debug,

    All

  };


  /******/


  static LogLevel logLevel()
    { return s_logLevel; }

  static void setLogLevel( LogLevel level )
    { s_logLevel = level; }

  static const char* logFileName();


  static void init
    // 0 => use maximum value (currently 1G)
    (LogLevel level, const char* logFileName, int32 logFileLimit = 0, int64 logDiskSpaceLimit = 0);


  static void close();


  static const char* levelToChars(Log::LogLevel level);


  static LogLevel charsToLevel(const char* chars);


  static char* formatLogLine(char* buf, LogLevel level);

  /******/


  static bool enabled(LogLevel level)
  {
    return
      (((s_doingDebug && level == Debug) ||
        GEMFIRE_HIGHEST_LOG_LEVEL >= level) && s_logLevel >= level);
  }


  static void log(LogLevel level, const char* msg)
  {
    if (enabled(level))
      put(level, msg);
  }


  static void logThrow(LogLevel level, const char* msg, const Exception& ex)
  {
    if (enabled(level))
      putThrow(level, msg, ex);
  }


  static void logCatch(LogLevel level, const char* msg, const Exception& ex)
  {
    if (enabled(level))
      putCatch(level, msg, ex);
  }


  /******/


  static bool errorEnabled()
  {
    return GEMFIRE_HIGHEST_LOG_LEVEL >= Error && s_logLevel >= Error;
  }


  static void error(const char* msg)
  {
    if (errorEnabled())
      put(Error, msg);
  }


  static void errorThrow(const char* msg, const Exception& ex)
  {
    if (errorEnabled())
      putThrow(Error, msg, ex);
  }

  static void errorCatch(const char* msg, const Exception& ex)
  {
    if (errorEnabled())
      putCatch(Error, msg, ex);
  }


  /******/


  static bool warningEnabled()
  {
    return GEMFIRE_HIGHEST_LOG_LEVEL >= Warning && s_logLevel >= Warning;
  }


  static void warning(const char* msg)
  {
    if (warningEnabled())
      put(Warning, msg);
  }


  static void warningThrow(const char* msg, const Exception& ex)
  {
    if (warningEnabled())
      putThrow(Warning, msg, ex);
  }


  static void warningCatch(const char* msg, const Exception& ex)
  {
    if (warningEnabled())
      putCatch(Warning, msg, ex);
  }


  /******/


  static bool infoEnabled()
  {
    return GEMFIRE_HIGHEST_LOG_LEVEL >= Info && s_logLevel >= Info;
  }


  static void info(const char* msg)
  {
    if (infoEnabled())
      put(Info, msg);
  }


  static void infoThrow(const char* msg, const Exception& ex)
  {
    if (infoEnabled())
      putThrow(Info, msg, ex);
  }


  static void infoCatch(const char* msg, const Exception& ex)
  {
    if (infoEnabled())
      putCatch(Info, msg, ex);
  }


  /******/


  static bool configEnabled()
  {
    return GEMFIRE_HIGHEST_LOG_LEVEL >= Config && s_logLevel >= Config;
  }


  static void config(const char* msg)
  {
    if (configEnabled())
      put(Config, msg);
  }


  static void configThrow(const char* msg, const Exception& ex)
  {
    if (configEnabled())
      putThrow(Config, msg, ex);
  }


  static void configCatch(const char* msg, const Exception& ex)
  {
    if (configEnabled())
      putCatch(Config, msg, ex);
  }


  /******/


  static bool fineEnabled()
  {
    return GEMFIRE_HIGHEST_LOG_LEVEL >= Fine && s_logLevel >= Fine;
  }


  static void fine(const char* msg)
  {
    if (fineEnabled())
      put(Fine, msg);
  }


  static void fineThrow(const char* msg, const Exception& ex)
  {
    if (fineEnabled())
      putThrow(Fine, msg, ex);
  }


  static void fineCatch(const char* msg, const Exception& ex)
  {
    if (fineEnabled())
      putCatch(Fine, msg, ex);
  }


  /******/


  static bool finerEnabled()
  {
    return GEMFIRE_HIGHEST_LOG_LEVEL >= Finer && s_logLevel >= Finer;
  }


  static void finer(const char* msg)
  {
    if (finerEnabled())
      put(Finer, msg);
  }


  static void finerThrow(const char* msg, const Exception& ex)
  {
    if (finerEnabled())
      putThrow(Finer, msg, ex);
  }


  static void finerCatch(const char* msg, const Exception& ex)
  {
    if (finerEnabled())
      putCatch(Finer, msg, ex);
  }


  /******/


  static bool finestEnabled()
  {
    return GEMFIRE_HIGHEST_LOG_LEVEL >= Finest && s_logLevel >= Finest;
  }


  static void finest(const char* msg)
  {
    if (finestEnabled())
      put(Finest, msg);
  }


  static void finestThrow(const char* msg, const Exception& ex)
  {
    if (finestEnabled())
      putThrow(Finest, msg, ex);
  }


  static void finestCatch(const char* msg, const Exception& ex)
  {
    if (finestEnabled())
      putCatch(Finest, msg, ex);
  }


  /******/


  static bool debugEnabled()
  {
    return (s_doingDebug || GEMFIRE_HIGHEST_LOG_LEVEL >= Debug) &&
      s_logLevel >= Debug;
  }


  static void debug(const char* msg)
  {
    if (debugEnabled())
      put(Debug, msg);
  }


  static void debugThrow(const char* msg, const Exception& ex)
  {
    if (debugEnabled())
      putThrow(Debug, msg, ex);
  }


  static void debugCatch(const char* msg, const Exception& ex)
  {
    if (debugEnabled())
      putCatch(Debug, msg, ex);
  }


  /******/


  static void enterFn(LogLevel level, const char* functionName);


  static void exitFn(LogLevel level, const char* functionName);



  /******/

private:


  static LogLevel s_logLevel;


  /******/

#ifdef DEBUG
  enum { s_doingDebug = 1 };
#else
  enum { s_doingDebug = 0 };
#endif


  /******/


  static void writeBanner();


  /******/
public:

  static void put(LogLevel level, const char* msg);

  static void putThrow
    (LogLevel level, const char* msg, const Exception& ex);

  static void putCatch
    (LogLevel level, const char* msg, const Exception& ex);

};


/******************************************************************************/
/******************************************************************************/


class LogFn {

  const char* m_functionName;
  Log::LogLevel m_level;

public:

  LogFn(const char* functionName, Log::LogLevel level = Log::Finest)
    : m_functionName(functionName), m_level(level)
  {
    if (Log::enabled(m_level))
      Log::enterFn(m_level, m_functionName);
  }

  ~LogFn()
  {
    if (Log::enabled(m_level))
      Log::exitFn(m_level, m_functionName);
  }

private:
  LogFn(const LogFn& rhs); // never defined
  void operator = (const LogFn& rhs); // never defined
};

/******************************************************************************/
/******************************************************************************/

class CPPCACHE_EXPORT LogVarargs
{
  public:

  static void debug( const char* fmt, ...);
  static void error( const char* fmt, ...);
  static void warn( const char* fmt, ...);
  static void info( const char* fmt, ...);
  static void config( const char* fmt, ...);
  static void fine( const char* fmt, ...);
  static void finer( const char* fmt, ...);
  static void finest( const char* fmt, ...);

};

}

/************************ LOGDEBUG ***********************************/

#define LOGDEBUG if ( gemfire::Log::Debug <= gemfire::Log::logLevel() ) gemfire::LogVarargs::debug

/************************ LOGERROR ***********************************/

#define LOGERROR if ( gemfire::Log::Error <= gemfire::Log::logLevel() ) gemfire::LogVarargs::error

/************************ LOGWARN ***********************************/

#define LOGWARN if ( gemfire::Log::Warning <= gemfire::Log::logLevel() ) gemfire::LogVarargs::warn

/************************ LOGINFO ***********************************/

#define LOGINFO if ( gemfire::Log::Info <= gemfire::Log::logLevel() ) gemfire::LogVarargs::info

/************************ LOGCONFIG ***********************************/

#define LOGCONFIG if ( gemfire::Log::Config <= gemfire::Log::logLevel() ) gemfire::LogVarargs::config

/************************ LOGFINE ***********************************/

#define LOGFINE if ( gemfire::Log::Fine <= gemfire::Log::logLevel() ) gemfire::LogVarargs::fine

/************************ LOGFINER ***********************************/

#define LOGFINER if ( gemfire::Log::Finer <= gemfire::Log::logLevel() ) gemfire::LogVarargs::finer

/************************ LOGFINEST ***********************************/

#define LOGFINEST if ( gemfire::Log::Finest <= gemfire::Log::logLevel() ) gemfire::LogVarargs::finest

/******************************************************************************/


/******************************************************************************/


#endif


/******************************************************************************/

---