miniglog/glog/logging.h

// Copyright 2011 Google Inc. All Rights Reserved.
// Author: settinger@google.com (Scott Ettinger)

// Simplified Google3 style logging with Android support.
// Supported macros are : LOG(INFO), LOG(WARNING), LOG(ERROR), LOG(FATAL),
//                        and VLOG(n).
//
// Portions of this code are taken from the GLOG package.  This code
// is only a small subset of the GLOG functionality. And like GLOG,
// higher levels are more verbose.
//
// Notable differences from GLOG :
//
// 1. lack of support for displaying unprintable characters and lack
// of stack trace information upon failure of the CHECK macros.
// 2. All output is tagged with the string "native".
// 3. While there is no runtime flag filtering logs (-v, -vmodule), the
//    compile time define MAX_LOG_LEVEL can be used to silence any
//    logging above the given level.
//
// -------------------------------- Usage ------------------------------------
// Basic usage :
// LOG(<severity level>) acts as a c++ stream to the Android logcat output.
// e.g. LOG(INFO) << "Value of counter = " << counter;
//
// Valid severity levels include INFO, WARNING, ERROR, FATAL.
// The various severity levels are routed to the corresponding Android logcat
// output.
// LOG(FATAL) outputs to the log and then terminates.
//
// VLOG(<severity level>) can also be used.
// VLOG(n) output is directed to the Android logcat levels as follows :
//  >=2 - Verbose
//    1 - Debug
//    0 - Info
//   -1 - Warning
//   -2 - Error
// <=-3 - Fatal
// Note that VLOG(FATAL) will terminate the program.
//
// CHECK macros are defined to test for conditions within code.  Any CHECK
// that fails will log the failure and terminate the application.
// e.g. CHECK_GE(3, 2) will pass while CHECK_GE(3, 4) will fail after logging
//      "Check failed 3 >= 4".
// The following CHECK macros are defined :
//
// CHECK(condition) - fails if condition is false and logs condition.
// CHECK_NOTNULL(variable) - fails if the variable is NULL.
//
// The following binary check macros are also defined :
//    Macro                 operator applied
// ------------------------------------------
// CHECK_EQ(val1, val2)      val1 == val2
// CHECK_NE(val1, val2)      val1 != val2
// CHECK_GT(val1, val2)      val1 > val2
// CHECK_GE(val1, val2)      val1 >= val2
// CHECK_LT(val1, val2)      val1 < val2
// CHECK_LE(val1, val2)      val1 <= val2
//
// Debug only versions of all of the check macros are also defined.  These
// macros generate no code in a release build, but avoid unused variable
// warnings / errors.
// To use the debug only versions, Prepend a D to the normal check macros.
// e.g. DCHECK_EQ(a, b);

#ifndef MOBILE_BASE_LOGGING_H_
#define MOBILE_BASE_LOGGING_H_

// Definitions for building on an Android system.
#include <android/log.h>
#include <time.h>

#include <algorithm>
#include <iostream>
#include <string>
#include <fstream>
#include <set>
#include <sstream>
#include <vector>

// Log severity level constants.
const int FATAL   = -3;
const int ERROR   = -2;
const int WARNING = -1;
const int INFO    =  0;

// ------------------------- Glog compatibility ------------------------------

namespace google {

typedef int LogSeverity;
const int INFO    = ::INFO;
const int WARNING = ::WARNING;
const int ERROR   = ::ERROR;
const int FATAL   = ::FATAL;

#ifdef ENABLE_LOG_SINKS

// Sink class used for integration with mock and test functions.
// If sinks are added, all log output is also sent to each sink through
// the send function.  In this implementation, WaitTillSent() is called
// immediately after the send.
// This implementation is not thread safe.
class LogSink {
 public:
  virtual ~LogSink() {}
  virtual void send(LogSeverity severity, const char* full_filename,
                    const char* base_filename, int line,
                    const struct tm* tm_time,
                    const char* message, size_t message_len) = 0;
  virtual void WaitTillSent() = 0;
};

// Global set of log sinks.
// TODO(settinger): Move this into a .cc file.
static std::set<LogSink *> log_sinks_global;

// Note: the Log sink functions are not thread safe.
inline void AddLogSink(LogSink *sink) {
  // TODO(settinger): Add locks for thread safety.
  log_sinks_global.insert(sink);
}
inline void RemoveLogSink(LogSink *sink) {
  log_sinks_global.erase(sink);
}

#endif  // #ifdef ENABLE_LOG_SINKS

inline void InitGoogleLogging(char *argv) {}

}  // namespace google

// ---------------------------- Logger Class --------------------------------

// Class created for each use of the logging macros.
// The logger acts as a stream and routes the final stream contents to the
// Android logcat output at the proper filter level.  This class should not
// be directly instantiated in code, rather it should be invoked through the
// use of the log macros LOG, or VLOG.
class MessageLogger {
 public:
  MessageLogger(const char *file, int line, const char *tag, int severity)
    : file_(file), line_(line), tag_(tag), severity_(severity) {
    // Pre-pend the stream with the file and line number.
    StripBasename(std::string(file), &filename_only_);
    stream_ << filename_only_ << ":" << line << " ";
  }

  // Output the contents of the stream to the proper channel on destruction.
  ~MessageLogger() {
#ifdef MAX_LOG_LEVEL
    if (severity_ > MAX_LOG_LEVEL && severity_ > FATAL) {
      return;
    }
#endif
    stream_ << "\n";
    static const int android_log_levels[] = {
        ANDROID_LOG_FATAL,    // LOG(FATAL)
        ANDROID_LOG_ERROR,    // LOG(ERROR)
        ANDROID_LOG_WARN,     // LOG(WARNING)
        ANDROID_LOG_INFO,     // LOG(INFO), VLOG(0)
        ANDROID_LOG_DEBUG,    // VLOG(1)
        ANDROID_LOG_VERBOSE,  // VLOG(2) .. VLOG(N)
    };

    // Bound the logging level.
    const int kMaxVerboseLevel = 2;
    int android_level_index = std::min(std::max(FATAL, severity_),
                                       kMaxVerboseLevel) - FATAL;
    int android_log_level = android_log_levels[android_level_index];

    // Output the log string the Android log at the appropriate level.
    __android_log_write(android_log_level, tag_.c_str(), stream_.str().c_str());

    // Indicate termination if needed.
    if (severity_ == FATAL) {
      __android_log_write(ANDROID_LOG_FATAL,
                          tag_.c_str(),
                          "terminating.\n");
    }

#ifdef ENABLE_LOG_SINKS

    LogToSinks(severity_);
    WaitForSinks();

#endif  // #ifdef ENABLE_LOG_SINKS

    // Android logging at level FATAL does not terminate execution, so abort()
    // is still required to stop the program.
    if (severity_ == FATAL) {
      abort();
    }
  }

  // Return the stream associated with the logger object.
  std::stringstream &stream() { return stream_; }

 private:
#ifdef ENABLE_LOG_SINKS

  void LogToSinks(int severity) {
    time_t rawtime;
    struct tm * timeinfo;

    time ( &rawtime );
    timeinfo = localtime ( &rawtime );
    std::set<google::LogSink *>::iterator iter;
    // Send the log message to all sinks.
    for (iter = google::log_sinks_global.begin();
         iter != google::log_sinks_global.end(); ++iter)
      (*iter)->send(severity, file_.c_str(), filename_only_.c_str(), line_,
                    timeinfo, stream_.str().c_str(), stream_.str().size());
  }

  void WaitForSinks() {
    // TODO(settinger): add locks for thread safety.
    std::set<google::LogSink *>::iterator iter;
    // Call WaitTillSent() for all sinks.
    for (iter = google::log_sinks_global.begin();
         iter != google::log_sinks_global.end(); ++iter)
      (*iter)->WaitTillSent();
  }

#endif // #ifdef ENABLE_LOG_SINKS

  void StripBasename(const std::string &full_path, std::string *filename) {
    // TODO(settinger): add support for OS with different path separators.
    const char kSeparator = '/';
    size_t pos = full_path.rfind(kSeparator);
    if (pos != std::string::npos)
      *filename = full_path.substr(pos + 1, std::string::npos);
    else
      *filename = full_path;
  }

  std::string file_;
  std::string filename_only_;
  int line_;
  std::string tag_;
  std::stringstream stream_;
  int severity_;
};

// ---------------------- Logging Macro definitions --------------------------

// This class is used to explicitly ignore values in the conditional
// logging macros.  This avoids compiler warnings like "value computed
// is not used" and "statement has no effect".
class LoggerVoidify {
 public:
  LoggerVoidify() { }
  // This has to be an operator with a precedence lower than << but
  // higher than ?:
  void operator&(const std::ostream &s) { }
};

// Log only if condition is met.  Otherwise evaluates to void.
#define LOG_IF(severity, condition) \
  !(condition) ? (void) 0 : LoggerVoidify() & \
    MessageLogger((char *)__FILE__, __LINE__, "native", severity).stream()

// Log only if condition is NOT met.  Otherwise evaluates to void.
#define LOG_IF_FALSE(severity, condition) LOG_IF(severity, !(condition))

// LG is a convenient shortcut for LOG(INFO). Its use is in new
// google3 code is discouraged and the following shortcut exists for
// backward compatibility with existing code.
#ifdef MAX_LOG_LEVEL
#define LOG(n) LOG_IF(n, n <= MAX_LOG_LEVEL)
#define VLOG(n) LOG_IF(n, n <= MAX_LOG_LEVEL)
#define LG LOG_IF(INFO, INFO <= MAX_LOG_LEVEL)
#else
#define LOG(n) MessageLogger((char *)__FILE__, __LINE__, "native", n).stream()
#define VLOG(n) MessageLogger((char *)__FILE__, __LINE__, "native", n).stream()
#define LG MessageLogger((char *)__FILE__, __LINE__, "native", INFO).stream()
#endif

// Currently, VLOG is always on for levels below MAX_LOG_LEVEL.
#ifndef MAX_LOG_LEVEL
#define VLOG_IS_ON(x) (1)
#else
#define VLOG_IS_ON(x) (x <= MAX_LOG_LEVEL)
#endif

#ifndef NDEBUG
#define DLOG LOG
#else
#define DLOG(severity) true ? (void) 0 : LoggerVoidify() & \
    MessageLogger((char *)__FILE__, __LINE__, "native", severity).stream()
#endif

// ---------------------------- CHECK helpers --------------------------------

// Log a message and terminate.
template<class T>
void LogMessageFatal(const char *file, int line, const T &message) {
  MessageLogger((char *)__FILE__, __LINE__, "native", FATAL).stream()
      << message;
}

// ---------------------------- CHECK macros ---------------------------------

// Check for a given boolean condition.
#define CHECK(condition) LOG_IF_FALSE(FATAL, condition) \
        << "Check failed: " #condition " "

#ifndef NDEBUG
// Debug only version of CHECK
#define DCHECK(condition) LOG_IF_FALSE(FATAL, condition) \
        << "Check failed: " #condition " "
#else
// Optimized version - generates no code.
#define DCHECK(condition) if (false) LOG_IF_FALSE(FATAL, condition) \
        << "Check failed: " #condition " "
#endif  // NDEBUG

// ------------------------- CHECK_OP macros ---------------------------------

// Generic binary operator check macro. This should not be directly invoked,
// instead use the binary comparison macros defined below.
#define CHECK_OP(val1, val2, op) LOG_IF_FALSE(FATAL, (val1 op val2)) \
  << "Check failed: " #val1 " " #op " " #val2 " "

// Check_op macro definitions
#define CHECK_EQ(val1, val2) CHECK_OP(val1, val2, ==)
#define CHECK_NE(val1, val2) CHECK_OP(val1, val2, !=)
#define CHECK_LE(val1, val2) CHECK_OP(val1, val2, <=)
#define CHECK_LT(val1, val2) CHECK_OP(val1, val2, <)
#define CHECK_GE(val1, val2) CHECK_OP(val1, val2, >=)
#define CHECK_GT(val1, val2) CHECK_OP(val1, val2, >)

#ifndef NDEBUG
// Debug only versions of CHECK_OP macros.
#define DCHECK_EQ(val1, val2) CHECK_OP(val1, val2, ==)
#define DCHECK_NE(val1, val2) CHECK_OP(val1, val2, !=)
#define DCHECK_LE(val1, val2) CHECK_OP(val1, val2, <=)
#define DCHECK_LT(val1, val2) CHECK_OP(val1, val2, <)
#define DCHECK_GE(val1, val2) CHECK_OP(val1, val2, >=)
#define DCHECK_GT(val1, val2) CHECK_OP(val1, val2, >)
#else
// These versions generate no code in optimized mode.
#define DCHECK_EQ(val1, val2) if (false) CHECK_OP(val1, val2, ==)
#define DCHECK_NE(val1, val2) if (false) CHECK_OP(val1, val2, !=)
#define DCHECK_LE(val1, val2) if (false) CHECK_OP(val1, val2, <=)
#define DCHECK_LT(val1, val2) if (false) CHECK_OP(val1, val2, <)
#define DCHECK_GE(val1, val2) if (false) CHECK_OP(val1, val2, >=)
#define DCHECK_GT(val1, val2) if (false) CHECK_OP(val1, val2, >)
#endif  // NDEBUG

// ---------------------------CHECK_NOTNULL macros ---------------------------

// Helpers for CHECK_NOTNULL(). Two are necessary to support both raw pointers
// and smart pointers.
template <typename T>
T& CheckNotNullCommon(const char *file, int line, const char *names, T& t) {
  if (t == NULL) {
    LogMessageFatal(file, line, std::string(names));
  }
  return t;
}

template <typename T>
T* CheckNotNull(const char *file, int line, const char *names, T* t) {
  return CheckNotNullCommon(file, line, names, t);
}

template <typename T>
T& CheckNotNull(const char *file, int line, const char *names, T& t) {
  return CheckNotNullCommon(file, line, names, t);
}

// Check that a pointer is not null.
#define CHECK_NOTNULL(val) \
  CheckNotNull(__FILE__, __LINE__, "'" #val "' Must be non NULL", (val))

#ifndef NDEBUG
// Debug only version of CHECK_NOTNULL
#define DCHECK_NOTNULL(val) \
  CheckNotNull(__FILE__, __LINE__, "'" #val "' Must be non NULL", (val))
#else
// Optimized version - generates no code.
#define DCHECK_NOTNULL(val) if (false)\
  CheckNotNull(__FILE__, __LINE__, "'" #val "' Must be non NULL", (val))
#endif  // NDEBUG

inline void PrintAndroid(const char *msg) {
  __android_log_write(ANDROID_LOG_VERBOSE, "native", msg);
}

#endif  // MOBILE_BASE_LOGGING_H_