mlog.cpp File Reference

#include <time.h>
#include <atomic>
#include <boost/filesystem.hpp>
#include <boost/algorithm/string.hpp>
#include "string_tools.h"
#include "misc_os_dependent.h"
#include "misc_log_ex.h"

Include dependency graph for mlog.cpp:

Go to the source code of this file.

Namespaces
namespace	epee

Macros
#define	_MLOG_H_
#define	ELECTRONEUM_DEFAULT_LOG_CATEGORY   "logging"
#define	MLOG_BASE_FORMAT   "%datetime{%Y-%M-%d %H:%m:%s.%g}\t%thread\t%level\t%logger\t%loc\t%msg"
#define	MLOG_LOG(x)

Functions
std::string	mlog_get_default_log_path (const char *default_filename)
void	mlog_configure (const std::string &filename_base, bool console, const std::size_t max_log_file_size, const std::size_t max_log_files)
void	mlog_set_categories (const char *categories)
std::string	mlog_get_categories ()
void	mlog_set_log_level (int level)
void	mlog_set_log (const char *log)
bool	epee::is_stdout_a_tty ()
void	epee::set_console_color (int color, bool bright)
void	epee::reset_console_color ()

Macro Definition Documentation

_MLOG_H_

#define _MLOG_H_

Definition at line 29 of file mlog.cpp.

ELECTRONEUM_DEFAULT_LOG_CATEGORY

#define ELECTRONEUM_DEFAULT_LOG_CATEGORY   "logging"

Definition at line 47 of file mlog.cpp.

MLOG_BASE_FORMAT

#define MLOG_BASE_FORMAT   "%datetime{%Y-%M-%d %H:%m:%s.%g}\t%thread\t%level\t%logger\t%loc\t%msg"

Definition at line 49 of file mlog.cpp.

MLOG_LOG

#define MLOG_LOG

(

x

)

Value:

CINFO(el::base::Writer,el::base::DispatchAction::FileOnlyLog,ELECTRONEUM_DEFAULT_LOG_CATEGORY) << x

Definition at line 51 of file mlog.cpp.

Function Documentation

mlog_configure()

void mlog_configure	(	const std::string &	filename_base,
		bool	console,
		const std::size_t	max_log_file_size,
		const std::size_t	max_log_files )

Definition at line 148 of file mlog.cpp.

{
  el::Configurations c;
  c.setGlobally(el::ConfigurationType::Filename, filename_base);
  c.setGlobally(el::ConfigurationType::ToFile, "true");
  const char *log_format = getenv("ELECTRONEUM_LOG_FORMAT");
  if (!log_format)
    log_format = MLOG_BASE_FORMAT;
  c.setGlobally(el::ConfigurationType::Format, log_format);
  c.setGlobally(el::ConfigurationType::ToStandardOutput, console ? "true" : "false");
  c.setGlobally(el::ConfigurationType::MaxLogFileSize, std::to_string(max_log_file_size));
  el::Loggers::setDefaultConfigurations(c, true);
 
  el::Loggers::addFlag(el::LoggingFlag::HierarchicalLogging);
  el::Loggers::addFlag(el::LoggingFlag::CreateLoggerAutomatically);
  el::Loggers::addFlag(el::LoggingFlag::DisableApplicationAbortOnFatalLog);
  el::Loggers::addFlag(el::LoggingFlag::ColoredTerminalOutput);
  el::Loggers::addFlag(el::LoggingFlag::StrictLogFileSizeCheck);
  el::Helpers::installPreRollOutCallback([filename_base, max_log_files](const char *name, size_t){
    std::string rname = generate_log_filename(filename_base.c_str());
    int ret = rename(name, rname.c_str());
    if (ret < 0)
    {
      // can't log a failure, but don't do the file removal below
      return;
    }
    if (max_log_files != 0)
    {
      std::vector<boost::filesystem::path> found_files;
      const boost::filesystem::directory_iterator end_itr;
      const boost::filesystem::path filename_base_path(filename_base);
      const boost::filesystem::path parent_path = filename_base_path.has_parent_path() ? filename_base_path.parent_path() : ".";
      for (boost::filesystem::directory_iterator iter(parent_path); iter != end_itr; ++iter)
      {
        const std::string filename = iter->path().string();
        if (filename.size() >= filename_base.size() && std::memcmp(filename.data(), filename_base.data(), filename_base.size()) == 0)
        {
          found_files.push_back(iter->path());
        }
      }
      if (found_files.size() >= max_log_files)
      {
        std::sort(found_files.begin(), found_files.end(), [](const boost::filesystem::path &a, const boost::filesystem::path &b) {
          boost::system::error_code ec;
          std::time_t ta = boost::filesystem::last_write_time(boost::filesystem::path(a), ec);
          if (ec)
          {
            MERROR("Failed to get timestamp from " << a << ": " << ec);
            ta = std::time(nullptr);
          }
          std::time_t tb = boost::filesystem::last_write_time(boost::filesystem::path(b), ec);
          if (ec)
          {
            MERROR("Failed to get timestamp from " << b << ": " << ec);
            tb = std::time(nullptr);
          }
          static_assert(std::is_integral<time_t>(), "bad time_t");
          return ta < tb;
        });
        for (size_t i = 0; i <= found_files.size() - max_log_files; ++i)
        {
          try
          {
            boost::system::error_code ec;
            boost::filesystem::remove(found_files[i], ec);
            if (ec)
            {
              MERROR("Failed to remove " << found_files[i] << ": " << ec);
            }
          }
          catch (const std::exception &e)
          {
            MERROR("Failed to remove " << found_files[i] << ": " << e.what());
          }
        }
      }
    }
  });
  mlog_set_common_prefix();
  const char *electroneum_log = getenv("ELECTRONEUM_LOGS");
  if (!electroneum_log)
  {
    electroneum_log = get_default_categories(0);
  }
  mlog_set_log(electroneum_log);
#ifdef WIN32
  EnableVTMode();
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

mlog_get_categories()

std::string mlog_get_categories

(

)

Definition at line 276 of file mlog.cpp.

{
  return el::Loggers::getCategories();
}

Here is the call graph for this function:

Here is the caller graph for this function:

mlog_get_default_log_path()

std::string mlog_get_default_log_path

(

const char *

default_filename

)

Definition at line 72 of file mlog.cpp.

{
  std::string process_name = epee::string_tools::get_current_module_name();
  std::string default_log_folder = epee::string_tools::get_current_module_folder();
  std::string default_log_file = process_name;
  std::string::size_type a = default_log_file.rfind('.');
  if ( a != std::string::npos )
    default_log_file.erase( a, default_log_file.size());
  if ( ! default_log_file.empty() )
    default_log_file += ".log";
  else
    default_log_file = default_filename;
 
  return (boost::filesystem::path(default_log_folder) / boost::filesystem::path(default_log_file)).string();
}

Here is the call graph for this function:

Here is the caller graph for this function:

mlog_set_categories()

void mlog_set_categories

(

const char *

categories

)

Definition at line 238 of file mlog.cpp.

{
  std::string new_categories;
  if (*categories)
  {
    if (*categories == '+')
    {
      ++categories;
      new_categories = mlog_get_categories();
      if (*categories)
      {
        if (!new_categories.empty())
          new_categories += ",";
        new_categories += categories;
      }
    }
    else if (*categories == '-')
    {
      ++categories;
      new_categories = mlog_get_categories();
      std::vector<std::string> single_categories;
      boost::split(single_categories, categories, boost::is_any_of(","), boost::token_compress_on);
      for (const std::string &s: single_categories)
      {
        size_t pos = new_categories.find(s);
        if (pos != std::string::npos)
          new_categories = new_categories.erase(pos, s.size());
      }
    }
    else
    {
      new_categories = categories;
    }
  }
  el::Loggers::setCategories(new_categories.c_str(), true);
  MLOG_LOG("New log categories: " << el::Loggers::getCategories());
}

Here is the call graph for this function:

Here is the caller graph for this function:

mlog_set_log()

void mlog_set_log

(

const char *

log

)

Definition at line 288 of file mlog.cpp.

{
  long level;
  char *ptr = NULL;
 
  if (!*log)
  {
    mlog_set_categories(log);
    return;
  }
  level = strtol(log, &ptr, 10);
  if (ptr && *ptr)
  {
    // we can have a default level, eg, 2,foo:ERROR
    if (*ptr == ',') {
      std::string new_categories = std::string(get_default_categories(level)) + ptr;
      mlog_set_categories(new_categories.c_str());
    }
    else {
      mlog_set_categories(log);
    }
  }
  else if (level >= 0 && level <= 4)
  {
    mlog_set_log_level(level);
  }
  else
  {
    MERROR("Invalid numerical log level: " << log);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mlog_set_log_level()

void mlog_set_log_level

(

int

level

)

Definition at line 282 of file mlog.cpp.

{
  const char *categories = get_default_categories(level);
  mlog_set_categories(categories);
}

Here is the call graph for this function:

Here is the caller graph for this function: