MoFEM::LogManager Struct Reference

Log manager is used to build and partition problems. More...

#include "src/interfaces/LogManager.hpp"

Inheritance diagram for MoFEM::LogManager:

Collaboration diagram for MoFEM::LogManager:

Classes
struct	InternalData

Public Types
enum	SeverityLevel {   noisy , verbose , inform , warning ,   error }
	Severity levels. More...
enum	LogAttributesBits { BitLineID = 1 << 0 , BitScope = 1 << 1 }
	Tag attributes switches. More...
typedef boost::log::sources::severity_channel_logger< SeverityLevel, std::string >	LoggerType
	Definition of the channel logger.
typedef sinks::synchronous_sink< sinks::text_ostream_backend >	SinkType

Public Member Functions
MoFEMErrorCode	query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const
	LogManager (const MoFEM::Core &core)
virtual	~LogManager ()=default
Public Member Functions inherited from MoFEM::UnknownInterface
template<class IFACE >
MoFEMErrorCode	registerInterface (bool error_if_registration_failed=true)
	Register interface.
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE *&iface) const
	Get interface reference to pointer of interface.
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE **const iface) const
	Get interface pointer to pointer of interface.
template<class IFACE , typename boost::enable_if< boost::is_pointer< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get interface pointer to pointer of interface.
template<class IFACE , typename boost::enable_if< boost::is_reference< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get reference to interface.
template<class IFACE >
IFACE *	getInterface () const
	Function returning pointer to interface.
virtual	~UnknownInterface ()=default

Static Public Member Functions
static void	addAttributes (LogManager::LoggerType &lg, const int bit=0)
	Add attributes to logger.
static void	addAttributes (const std::string channel, const int bit=0)
	Add attributes to channel.
static LoggerType &	setLog (const std::string channel)
	Set ans resset chanel logger.
static LoggerType &	getLog (const std::string channel)
	Get logger by channel.
static bool	checkIfChannelExist (const std::string channel)
	Check if channel exist.
static void	addTag (LogManager::LoggerType &lg, const std::string tag)
	Add tag to logger.
static void	addTag (const std::string channel, const std::string tag)
	Add tag to channel.
static boost::shared_ptr< std::ostream >	getStrmSelf ()
	Get the strm self object.
static boost::shared_ptr< std::ostream >	getStrmWorld ()
	Get the strm world object.
static boost::shared_ptr< std::ostream >	getStrmSync ()
	Get the strm sync object.
static boost::shared_ptr< std::ostream >	getStrmNull ()
	Get the strm null object.
static boost::shared_ptr< std::ostream >	getStrmSync (MPI_Comm comm, FILE *fd)
	Get the strm sync object.
static boost::shared_ptr< SinkType >	createSink (boost::shared_ptr< std::ostream > stream_ptr, std::string comm_filter)
	Create a sink object.
static void	createDefaultSinks (MPI_Comm comm)
	Create default sinks.
static MoFEMErrorCode	getOptions ()
	Get logger option.
static PetscErrorCode	logPetscFPrintf (FILE *fd, const char format[], va_list Argp)
	Use to handle PETSc output.
static std::string	getVLikeFormatedString (const char *fmt, va_list args)
	Converts formatted output to string.
static std::string	getCLikeFormatedString (const char *fmt,...)
	Converts formatted output to string.
static void	recordFormatterDefault (logging::record_view const &rec, logging::formatting_ostream &strm)
	Default record formatter.
Static Public Member Functions inherited from MoFEM::UnknownInterface
static MoFEMErrorCode	getLibVersion (Version &version)
	Get library version.
static MoFEMErrorCode	getFileVersion (moab::Interface &moab, Version &version)
	Get database major version.
static MoFEMErrorCode	setFileVersion (moab::Interface &moab, Version version=Version(MoFEM_VERSION_MAJOR, MoFEM_VERSION_MINOR, MoFEM_VERSION_BUILD))
	Get database major version.
static MoFEMErrorCode	getInterfaceVersion (Version &version)
	Get database major version.

Static Public Attributes
static constexpr std::array< char *const, error+1 >	severityStrings
static FILE *	dummy_mofem_fd = (FILE *)&dummy_file
	Dummy file pointer (DO NOT USE)

Private Attributes
MoFEM::Core &	cOre

Static Private Attributes
static boost::shared_ptr< InternalData >	internalDataPtr
static std::string	petscStringCache = std::string()

Detailed Description

Log manager is used to build and partition problems.

Examples

elasticity.cpp.

Definition at line 26 of file LogManager.hpp.

Member Typedef Documentation

LoggerType

boost::log::sources::severity_channel_logger<SeverityLevel, std::string> MoFEM::LogManager::LoggerType

Definition of the channel logger.

Definition at line 64 of file LogManager.hpp.

SinkType

sinks::synchronous_sink<sinks::text_ostream_backend> MoFEM::LogManager::SinkType

Definition at line 66 of file LogManager.hpp.

Constructor & Destructor Documentation

LogManager()

MoFEM::LogManager::LogManager

(

const MoFEM::Core &

core

)

Definition at line 138 of file LogManager.cpp.

    : cOre(const_cast<MoFEM::Core &>(core)) {}

~LogManager()

virtual MoFEM::LogManager::~LogManager ( )

virtualdefault

Member Function Documentation

checkIfChannelExist()

bool MoFEM::LogManager::checkIfChannelExist ( const std::string channel )

static

Check if channel exist.

Parameters

channel

Returns

true

false

Definition at line 407 of file LogManager.cpp.

                                                            {
  return InternalData::logChannels.find(channel) !=
         InternalData::logChannels.end();
}

createDefaultSinks()

void MoFEM::LogManager::createDefaultSinks ( MPI_Comm comm )

static

Create default sinks.

Definition at line 308 of file LogManager.cpp.

                                                 {
 
  internalDataPtr = boost::make_shared<InternalData>(comm);
 
  auto core_log = logging::core::get();
  core_log->remove_all_sinks();
  core_log->add_sink(LogManager::createSink(
      boost::shared_ptr<std::ostream>(&std::clog, boost::null_deleter()),
      "PETSC"));
  core_log->add_sink(createSink(getStrmSelf(), "SELF"));
  core_log->add_sink(createSink(getStrmWorld(), "WORLD"));
  core_log->add_sink(createSink(getStrmSync(), "SYNC"));
  core_log->add_sink(createSink(getStrmNull(), "NULL"));
 
  LogManager::setLog("PETSC");
  LogManager::setLog("SELF");
  LogManager::setLog("WORLD");
  LogManager::setLog("SYNC");
  LogManager::setLog("NULL");
 
  MOFEM_LOG_TAG("PETSC", "petsc");
 
  int rank;
  MPI_Comm_rank(comm, &rank);
  core_log->add_global_attribute("Proc", attrs::constant<unsigned int>(rank));
}

createSink()

boost::shared_ptr< LogManager::SinkType > MoFEM::LogManager::createSink ( boost::shared_ptr< std::ostream > stream_ptr, std::string comm_filter )

static

Create a sink object.

Parameters

stream_ptr
comm_filter

Returns

boost::shared_ptr<SinkType>

Definition at line 293 of file LogManager.cpp.

                                              {
 
  auto backend = boost::make_shared<sinks::text_ostream_backend>();
  if (stream_ptr)
    backend->add_stream(stream_ptr);
  backend->auto_flush(true);
 
  auto sink = boost::make_shared<SinkType>(backend);
  sink->set_filter((expr::has_attr(channel) && channel == comm_filter));
  sink->set_formatter(&recordFormatterDefault);
 
  return sink;
}

getCLikeFormatedString()

std::string MoFEM::LogManager::getCLikeFormatedString ( const char * fmt, ... )

static

Converts formatted output to string.

Parameters

fmt
args

Returns

std::string

Definition at line 474 of file LogManager.cpp.

                                                                 {
  va_list args;
  va_start(args, fmt);
  auto str = getVLikeFormatedString(fmt, args);
  va_end(args);
  return str;
}

getOptions()

MoFEMErrorCode MoFEM::LogManager::getOptions ( )

static

Get logger option.

This function is called by MoFEM core when this interface is registred into database.

Returns

MoFEMErrorCode

Definition at line 149 of file LogManager.cpp.

                                      {
  MoFEMFunctionBegin;
  PetscInt sev_level = SeverityLevel::inform;
  PetscBool log_scope = PETSC_FALSE;
  PetscBool log_quiet = PETSC_FALSE;
  PetscBool log_no_colors = PETSC_FALSE;
  PetscBool log_time = PETSC_FALSE;
 
  PetscOptionsBegin(PETSC_COMM_WORLD, "log_", "Logging interface options",
                    "none");
 
  CHKERR PetscOptionsEList("-severity_level", "Severity level", "",
                           severityStrings.data(), SeverityLevel::error + 1,
                           severityStrings[sev_level], &sev_level,
                           PETSC_NULLPTR);
  CHKERR PetscOptionsEList("-sl", "Severity level", "", severityStrings.data(),
                           SeverityLevel::error + 1, severityStrings[sev_level],
                           &sev_level, PETSC_NULLPTR);
 
  CHKERR PetscOptionsBool("-scope", "Log scope", "", log_scope, &log_scope,
                          NULL);
 
  CHKERR PetscOptionsBool("-quiet", "Quiet log attributes", "", log_quiet,
                          &log_quiet, NULL);
 
  CHKERR PetscOptionsBool("-no_color", "Terminal with no colors", "",
                          log_no_colors, &log_no_colors, NULL);
  CHKERR PetscOptionsBool("-nc", "Terminal with no colors", "", log_no_colors,
                          &log_no_colors, NULL);
 
  CHKERR PetscOptionsBool("-time", "Log time", "", log_time, &log_time, NULL);
 
  PetscOptionsEnd();
 
  logging::core::get()->set_filter(MoFEM::LogKeywords::severity >= sev_level);
 
  if (log_scope)
    logging::core::get()->add_global_attribute("Scope", attrs::named_scope());
 
  if (log_quiet)
    LogManager::InternalData::logQuiet = true;
 
  if (log_no_colors)
    LogManager::InternalData::noColors = true;
 
  if (log_time)
    LogManager::InternalData::logTime = true;
 
  MoFEMFunctionReturn(0);
}

getStrmNull()

boost::shared_ptr< std::ostream > MoFEM::LogManager::getStrmNull ( )

static

Get the strm null object.

Returns

boost::shared_ptr<std::ostream>

Definition at line 347 of file LogManager.cpp.

                                                    {
  return internalDataPtr->getStrmNull();
}

getStrmSelf()

boost::shared_ptr< std::ostream > MoFEM::LogManager::getStrmSelf ( )

static

Get the strm self object.

Returns

boost::shared_ptr<std::ostream>

Definition at line 335 of file LogManager.cpp.

                                                    {
  return internalDataPtr->getStrmSelf();
}

getStrmSync() [1/2]

boost::shared_ptr< std::ostream > MoFEM::LogManager::getStrmSync ( )

static

Get the strm sync object.

Returns

boost::shared_ptr<std::ostream>

Definition at line 343 of file LogManager.cpp.

                                                    {
  return internalDataPtr->getStrmSync();
}

getStrmSync() [2/2]

boost::shared_ptr< std::ostream > MoFEM::LogManager::getStrmSync ( MPI_Comm comm, FILE * fd )

static

Get the strm sync object.

Parameters

comm
fd

Returns

boost::shared_ptr<std::ostream>

Definition at line 351 of file LogManager.cpp.

                                                                  {
  auto buff_ptr =
      boost::make_shared<InternalData::SynchronizedStreamBuf>(comm, fd);
  return boost::shared_ptr<std::ostream>(buff_ptr,
                                         new std::ostream(buff_ptr.get()));
}

getStrmWorld()

boost::shared_ptr< std::ostream > MoFEM::LogManager::getStrmWorld ( )

static

Get the strm world object.

Returns

boost::shared_ptr<std::ostream>

Definition at line 339 of file LogManager.cpp.

                                                     {
  return internalDataPtr->getStrmWorld();
}

getVLikeFormatedString()

std::string MoFEM::LogManager::getVLikeFormatedString ( const char * fmt, va_list args )

static

Converts formatted output to string.

Parameters

fmt
args

Returns

std::string

Definition at line 468 of file LogManager.cpp.

                                                                          {
  std::array<char, 1024> buf;
  vsprintf(buf.data(), fmt, args);
  return std::string(buf.data());
}

logPetscFPrintf()

PetscErrorCode MoFEM::LogManager::logPetscFPrintf ( FILE * fd, const char format[], va_list Argp )

static

Use to handle PETSc output.

Note

This is for internal use only/

Parameters

fd
format
Argp

Returns

PetscErrorCode

Definition at line 414 of file LogManager.cpp.

                                                         {
  MoFEMFunctionBegin;
  if (fd != stdout && fd != stderr && fd != dummy_mofem_fd) {
    CHKERR PetscVFPrintfDefault(fd, format, Argp);
 
  } else {
 
    std::array<char, 1024> buff;
    size_t length;
    CHKERR PetscVSNPrintf(buff.data(), 1024, format, &length, Argp);
 
    auto get_str = [&buff]() {
      std::string str;
      if (!petscStringCache.empty())
        str = petscStringCache + std::string(buff.data());
      else
        str = std::string(buff.data());
      return str;
    };
    const auto str = get_str();
 
    if (!str.empty()) {
      if (fd != dummy_mofem_fd) {
 
        MoFEM::LogManager::SeverityLevel sev =
            MoFEM::LogManager::SeverityLevel::inform;
        if (str.find("WARNING") != std::string::npos)
          sev = MoFEM::LogManager::SeverityLevel::warning;
 
        std::istringstream is(str);
        std::string line;
        std::vector<std::string> log_list;
 
        while (getline(is, line, '\n'))
          log_list.push_back(line);
 
        if (str.back() != '\n') {
          petscStringCache = log_list.back();
          log_list.pop_back();
        } else
          petscStringCache.clear();
 
        for (auto &line : log_list)
          MOFEM_LOG("PETSC", sev) << line;
 
      } else {
        std::clog << str;
      }
    }
  }
  MoFEMFunctionReturn(0);
}

query_interface()

MoFEMErrorCode MoFEM::LogManager::query_interface ( boost::typeindex::type_index type_index, UnknownInterface ** iface ) const

virtual

Implements MoFEM::UnknownInterface.

Definition at line 142 of file LogManager.cpp.

                                                            {
  MoFEMFunctionBeginHot;
  *iface = const_cast<LogManager *>(this);
  MoFEMFunctionReturnHot(0);
}

recordFormatterDefault()

void MoFEM::LogManager::recordFormatterDefault ( logging::record_view const & rec, logging::formatting_ostream & strm )

static

Default record formatter.

Parameters

rec
strm

Definition at line 200 of file LogManager.cpp.

                                                                         {
 
  if (!LogManager::InternalData::logQuiet) {
 
    auto sev = rec[severity];
    auto p = rec[proc_attr];
    auto l = rec[line_id];
    auto s = rec[scope];
    auto tg = rec[tag_attr];
    auto tl = rec[timeline];
 
    auto set_color = [&](const auto str) {
#if defined(PETSC_HAVE_UNISTD_H) && defined(PETSC_USE_ISATTY)
      if (isatty(fileno(stdout)) && !LogManager::InternalData::noColors)
        strm << str;
#endif
    };
 
    if (LogManager::InternalData::logTime) {
 
      auto local_time = boost::posix_time::second_clock::local_time();
      strm << "(Local time ";
      strm << local_time.date().year() << "-" << local_time.date().month()
           << "-" << local_time.date().day() << " "
           << local_time.time_of_day().hours() << ":"
           << local_time.time_of_day().minutes() << ":"
           << local_time.time_of_day().seconds();
      strm << ") ";
    }
 
    if (!p.empty()) {
      strm << "[";
      set_color("\033[32m");
      strm << p;
      set_color("\033[0m");
      strm << "] ";
    }
 
    switch (sev.get()) {
    case SeverityLevel::error:
      set_color("\033[1m");
    case SeverityLevel::warning:
      set_color("\033[31m");
      break;
    case SeverityLevel::inform:
      set_color("\033[34m");
      break;
    case SeverityLevel::verbose:
      set_color("\033[35m");
      break;
    case SeverityLevel::noisy:
      set_color("\033[36m");
      break;
    }
 
    strm << sev;
 
    set_color("\033[0m");
 
    if (!l.empty())
      strm << std::hex << std::setw(8) << std::setfill('0') << l.get()
           << std::dec << std::setfill(' ') << ": ";
 
    if (!s.empty()) {
      for (::boost::log::attributes::named_scope_list::const_iterator iter =
               s->begin();
           iter != s->end(); ++iter) {
        const auto path = std::string(iter->file_name.data());
        const auto file = path.substr(path.find_last_of("/\\") + 1);
        strm << "(" << file << ":" << iter->line << ">" << iter->scope_name
             << ")";
      }
      strm << " ";
    }
 
    if (!tg.empty()) {
 
      set_color("\033[1m");
      strm << "[" << tg.get() << "] ";
      set_color("\033[0m");
    }
 
    if (!tl.empty())
      strm << "[" << tl.get() << "] ";
  }
 
  auto msg = rec[logging::expressions::smessage];
 
  strm << msg;
}

Member Data Documentation

cOre

MoFEM::Core& MoFEM::LogManager::cOre

private

Definition at line 243 of file LogManager.hpp.

dummy_mofem_fd

FILE * MoFEM::LogManager::dummy_mofem_fd = (FILE *)&dummy_file

static

Dummy file pointer (DO NOT USE)

Note

This is for internal use only/

Definition at line 200 of file LogManager.hpp.

internalDataPtr

boost::shared_ptr< LogManager::InternalData > MoFEM::LogManager::internalDataPtr

staticprivate

Definition at line 246 of file LogManager.hpp.

petscStringCache

std::string MoFEM::LogManager::petscStringCache = std::string()

staticprivate

Definition at line 248 of file LogManager.hpp.

severityStrings

std::array<char *const, error + 1> MoFEM::LogManager::severityStrings

inlinestaticconstexpr

Initial value:

= {
 
      (char *)"noisy", (char *)"verbose", (char *)"inform", (char *)"warning",
      (char *)"error"
 
  }

Definition at line 35 of file LogManager.hpp.

                                                                             {
 
      (char *)"noisy", (char *)"verbose", (char *)"inform", (char *)"warning",
      (char *)"error"
 
  };

---

The documentation for this struct was generated from the following files:

• src/interfaces/LogManager.hpp
• src/interfaces/impl/LogManager.cpp