Log.hpp

Go to the documentation of this file.

#pragma once

#ifndef GEODE_LOG_H_
#define GEODE_LOG_H_

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "geode_globals.hpp"
#include <cstdio>
#include <cstdarg>

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

#ifndef GEODE_HIGHEST_LOG_LEVEL
#define GEODE_HIGHEST_LOG_LEVEL All
#endif

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

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

#define _GF_MSG_LIMIT 8192

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

namespace apache {
namespace geode {
namespace client {

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 > apache::geode::client::Log::logLevel()) { \
  } else                                                \
    apache::geode::client::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_t logFileLimit = 0,
       int64_t 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) ||
             GEODE_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 GEODE_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 GEODE_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 GEODE_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 GEODE_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 GEODE_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 GEODE_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 GEODE_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 || GEODE_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, ...);
};
}  // namespace client
}  // namespace geode
}  // namespace apache

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

#define LOGDEBUG                              \
  if (apache::geode::client::Log::Debug <=    \
      apache::geode::client::Log::logLevel()) \
  apache::geode::client::LogVarargs::debug

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

#define LOGERROR                              \
  if (apache::geode::client::Log::Error <=    \
      apache::geode::client::Log::logLevel()) \
  apache::geode::client::LogVarargs::error

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

#define LOGWARN                               \
  if (apache::geode::client::Log::Warning <=  \
      apache::geode::client::Log::logLevel()) \
  apache::geode::client::LogVarargs::warn

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

#define LOGINFO                               \
  if (apache::geode::client::Log::Info <=     \
      apache::geode::client::Log::logLevel()) \
  apache::geode::client::LogVarargs::info

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

#define LOGCONFIG                             \
  if (apache::geode::client::Log::Config <=   \
      apache::geode::client::Log::logLevel()) \
  apache::geode::client::LogVarargs::config

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

#define LOGFINE                               \
  if (apache::geode::client::Log::Fine <=     \
      apache::geode::client::Log::logLevel()) \
  apache::geode::client::LogVarargs::fine

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

#define LOGFINER                              \
  if (apache::geode::client::Log::Finer <=    \
      apache::geode::client::Log::logLevel()) \
  apache::geode::client::LogVarargs::finer

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

#define LOGFINEST                             \
  if (apache::geode::client::Log::Finest <=   \
      apache::geode::client::Log::logLevel()) \
  apache::geode::client::LogVarargs::finest

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

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

#endif  // GEODE_LOG_H_