LogPythonInterface Class Reference

Thin wrapper to expose a usable interface to the logging framework in python. More...

#include <LogPythonInterface.h>

Public Member Functions
	LogPythonInterface ()
	ctor
void	setLogLevel (LogConfig::ELogLevel level)
	Set the log level.
void	setAbortLevel (LogConfig::ELogLevel level)
	Set the abort log level.
void	setDebugLevel (int level)
	Set the debug messaging level.
void	setLogInfo (LogConfig::ELogLevel level, int info)
	Set the printed log information for the given level.
void	setPackageLogConfig (const std::string &package, const LogConfig &config)
	Set LogConfig for a given package.
void	setMaxMessageRepetitions (unsigned repetitions)
	Set maximum number of repetitions before silencing "identical" log messages.
LogConfig::ELogLevel	getLogLevel ()
	Get the log level.
LogConfig::ELogLevel	getAbortLevel ()
	Get the abort level.
int	getDebugLevel ()
	Get the debug level.
int	getLogInfo (LogConfig::ELogLevel level)
	Get the printed log information for the given level.
LogConfig &	getPackageLogConfig (const std::string &package)
	Get the LogConfig for the given package.
LogConfig &	getModuleLogConfig (const std::string &module)
	Get the LogConfig for the given module.
unsigned	getMaxMessageRepetitions () const
	Get maximum number of repetitions before silencing "identical" log messages.
void	addLogFile (const std::string &filename, bool append=false)
	Add a file as output connection.
void	addLogConsole ()
	Add the console as output connection.
void	addLogJSON (bool complete)
	Add the console as output connection but print the log messages as json objects so that they can be parsed easily.
void	addLogUDP (const std::string &hostname, unsigned short port)
	Add a UDP server as an output connection.
void	addLogConsole (bool color)
	Add the console as output connection.
void	reset ()
	Reset logging connections.
void	zeroCounters ()
	Reset logging counters.
void	enableErrorSummary (bool on)
	Enable/Disable error summary.
void	setPythonLoggingEnabled (bool enabled) const
	Set flag if logging should be done via python sys.stdout
bool	getPythonLoggingEnabled () const
	Get flag if logging should be done via python sys.stdout
void	setEscapeNewlinesEnabled (bool enabled) const
	Set flag if newlines in log messages to console should be replaced by ' '.
bool	getEscapeNewlinesEnabled () const
	Get flag if newlines in log messages to console should be replaced by ' '`.
boost::python::dict	getLogStatistics ()
	return dict with log statistics

Static Public Member Functions
static boost::python::object	logDebug (boost::python::tuple args, const boost::python::dict &kwargs)
	Produce debug message.
static boost::python::object	logInfo (boost::python::tuple args, const boost::python::dict &kwargs)
	Produce info message.
static boost::python::object	logResult (boost::python::tuple args, const boost::python::dict &kwargs)
	Produce result message.
static boost::python::object	logWarning (boost::python::tuple args, const boost::python::dict &kwargs)
	Produce warning message.
static boost::python::object	logError (boost::python::tuple args, const boost::python::dict &kwargs)
	Produce error message.
static boost::python::object	logFatal (boost::python::tuple args, const boost::python::dict &kwargs)
	Produce fatal message.
static void	exposePythonAPI ()
	expose python API

Detailed Description

Thin wrapper to expose a usable interface to the logging framework in python.

This class exposes a object called "logging" to the python interface. With this object it is possible to set all properties of the logging system directly in the steering file in a consistent manner This class also exposes the LogConfig class as well as the LogConfig::ELogLevel and LogConfig::ELogInfo enums to make setting of properties more transparent by using the names and not just the values. To set or get the log level, one can simply do:

logging.log_level = LogLevel.FATAL print "Logging level set to", logging.log_level

This module also allows to send log messages directly from python to ease consistent error reporting throughout the framework

B2WARNING("This is a warning message");

For all features, see b2logging.py in the framework/examples folder

Definition at line 44 of file LogPythonInterface.h.

Constructor & Destructor Documentation

LogPythonInterface()

LogPythonInterface ( )

inline

ctor

Definition at line 47 of file LogPythonInterface.h.

{};

Member Function Documentation

addLogConsole() [1/2]

void addLogConsole

(

)

Add the console as output connection.

Color will be used automatically if supported

Definition at line 115 of file LogPythonInterface.cc.

{
  LogSystem::Instance().addLogConnection(new LogConnectionFilter(new LogConnectionConsole(STDOUT_FILENO)));
}

addLogConsole() [2/2]

void addLogConsole

(

bool

color

)

Add the console as output connection.

Parameters

color

Flag whether color should be used

Definition at line 120 of file LogPythonInterface.cc.

{
  LogSystem::Instance().addLogConnection(new LogConnectionFilter(new LogConnectionConsole(STDOUT_FILENO, color)));
}

addLogFile()

void addLogFile	(	const std::string &	filename,
		bool	append = false )

Add a file as output connection.

Parameters

filename	The text file name
append	Flag whether output should be appended to an existing file

Definition at line 110 of file LogPythonInterface.cc.

{
  LogSystem::Instance().addLogConnection(new LogConnectionFilter(new LogConnectionTxtFile(filename, append)));
}

addLogJSON()

void addLogJSON

(

bool

complete

)

Add the console as output connection but print the log messages as json objects so that they can be parsed easily.

Parameters

complete

if true ignore the log info configuration and print all parts of the log message.

Definition at line 100 of file LogPythonInterface.cc.

{
  LogSystem::Instance().addLogConnection(new LogConnectionJSON(complete));
}

addLogUDP()

void addLogUDP	(	const std::string &	hostname,
		unsigned short	port )

Add a UDP server as an output connection.

Parameters

hostname	the hostname of the UDP server. Will throw an exception if it can not be resolved.
port	the port to connect to

Definition at line 105 of file LogPythonInterface.cc.

{
  LogSystem::Instance().addLogConnection(new LogConnectionUDP(hostname, port));
}

enableErrorSummary()

void enableErrorSummary

(

bool

on

)

Enable/Disable error summary.

Definition at line 135 of file LogPythonInterface.cc.

{
  LogSystem::Instance().enableErrorSummary(on);
}

exposePythonAPI()

void exposePythonAPI ( )

static

expose python API

Expose python api.

Definition at line 193 of file LogPythonInterface.cc.

{
  // to avoid confusion between std::arg and boost::python::arg we want a shorthand namespace as well
  namespace bp = boost::python;
  scope global;
  docstring_options options(true, true, false); //userdef, py sigs, c++ sigs
 
  //Interface LogLevel enum
  enum_<LogConfig::ELogLevel>("LogLevel", R"DOCSTRING(Class for all possible log levels
 
.. attribute:: DEBUG
 
  The lowest possible severity meant for expert only information and disabled
  by default. In contrast to all other log levels DEBUG messages have an
  additional numeric indication of their priority called the ``debug_level`` to
  allow for different levels of verbosity.
 
  The agreed values for ``debug_level`` are
 
  * **0-9** for user code. These numbers are reserved for user analysis code and
    may not be used by any part of basf2.
  * **10-19** for analysis package code. The use case is that a user wants to debug
    problems in analysis jobs with the help of experts.
 
  * **20-29** for simulation/reconstruction code.
  * **30-39** for core framework code.
 
  .. note:: The default maximum debug level which will be shown when
            running ``basf2 --debug`` without any argument for ``--debug`` is **10**
 
 
.. attribute:: INFO
 
  Used for informational messages which are of use for the average user but not
  very important. Should be used very sparsely, everything which is of no
  interest to the average user should be a debug message.
 
.. attribute:: RESULT
 
  Informational message which don't indicate an error condition but are more
  important than a mere information. For example the calculated cross section
  or the output file name.
 
  .. deprecated:: release-01-00-00
     use `INFO <basf2.LogLevel.INFO>` messages instead
 
.. attribute:: WARNING
 
  For messages which indicate something which is not correct but not fatal to
  the processing. This should **not** be used to make informational messages
  more prominent and they should not be ignored by the user but they are not
  critical.
 
.. attribute:: ERROR
 
  For messages which indicate a clear error condition which needs to be
  recovered. If error messages are produced before event processing is started
  the processing will be aborted. During processing errors don't lead to a stop
  of the processing but still indicate a problem.
 
.. attribute:: FATAL
 
  For errors so severe that no recovery is possible. Emitting a fatal error
  will always stop the processing and the `B2FATAL` function is guaranteed to
  not return.
)DOCSTRING")
  .value(LogConfig::logLevelToString(LogConfig::c_Debug), LogConfig::c_Debug)
  .value(LogConfig::logLevelToString(LogConfig::c_Info), LogConfig::c_Info)
  .value(LogConfig::logLevelToString(LogConfig::c_Result), LogConfig::c_Result)
  .value(LogConfig::logLevelToString(LogConfig::c_Warning), LogConfig::c_Warning)
  .value(LogConfig::logLevelToString(LogConfig::c_Error), LogConfig::c_Error)
  .value(LogConfig::logLevelToString(LogConfig::c_Fatal), LogConfig::c_Fatal)
  .value(LogConfig::logLevelToString(LogConfig::c_Default), LogConfig::c_Default)
  ;
 
  //Interface LogInfo enum
  enum_<LogConfig::ELogInfo>("LogInfo", R"DOCSTRING(The different fields of a log message.
 
These fields can be used as a bitmask to configure the appearance of log messages.
 
.. attribute:: LEVEL
 
  The severity of the log message, one of `basf2.LogLevel`
 
.. attribute:: MESSAGE
 
  The actual log message
 
.. attribute:: MODULE
 
  The name of the module active when the message was emitted. Can be empty if
  no module was active (before/after processing or outside of the normal event
  loop)
 
.. attribute:: PACKAGE
 
  The package the code that emitted the message belongs to. This is empty for
  messages emitted by python scripts
 
.. attribute:: FUNCTION
 
  The function name that emitted the message
 
.. attribute:: FILE
 
  The filename containing the code emitting the message
 
.. attribute:: LINE
 
  The line number in the file emitting the message
)DOCSTRING")
  .value("LEVEL", LogConfig::c_Level)
  .value("MESSAGE", LogConfig::c_Message)
  .value("MODULE", LogConfig::c_Module)
  .value("PACKAGE", LogConfig::c_Package)
  .value("FUNCTION", LogConfig::c_Function)
  .value("FILE", LogConfig::c_File)
  .value("LINE", LogConfig::c_Line)
  .value("TIMESTAMP", LogConfig::c_Timestamp)
  ;
 
  //Interface LogConfig class
  class_<LogConfig>("LogConfig",
                    R"(Defines logging settings (log levels and items included in each message) for a certain context, e.g. a module or package.
 
.. seealso:: `logging.package(str) <basf2.LogPythonInterface.package>`)")
  .def(init<bp::optional<LogConfig::ELogLevel, int> >())
  .add_property("log_level",  &LogConfig::getLogLevel,  &LogConfig::setLogLevel, "set or get the current log level")
  .add_property("debug_level", &LogConfig::getDebugLevel, &LogConfig::setDebugLevel, "set or get the current debug level")
  .add_property("abort_level", &LogConfig::getAbortLevel, &LogConfig::setAbortLevel,
                "set or get the severity which causes program abort")
  .def("set_log_level", &LogConfig::setLogLevel, args("log_level"), R"DOC(
Set the minimum log level to be shown. Messages with a log level below this value will not be shown at all.
 
.. warning: Message with a level of `ERROR <LogLevel.ERROR>` or higher will always be shown and cannot be silenced.
)DOC")
  .def("set_debug_level", &LogConfig::setDebugLevel, args("debug_level"), R"DOC(
Set the maximum debug level to be shown. Any messages with log level `DEBUG <LogLevel.DEBUG>` and a larger debug level will not be shown.
 
.. seealso: the documentation of `DEBUG <LogLevel.DEBUG>` for suitable values
)DOC")
  .def("set_abort_level", &LogConfig::setAbortLevel, args("abort_level"), R"DOC(
Set the severity which causes program abort.
 
This can be set to a `LogLevel` which will cause the processing to be aborted if
a message with the given level or higher is encountered. The default is
`FATAL <LogLevel.FATAL>`. It cannot be set any higher but can be lowered.
)DOC")
  .def("set_info", &LogConfig::setLogInfo, args("log_level", "log_info"),
       "set the bitmask of LogInfo members to show when printing messages for a given log level")
  .def("get_info", &LogConfig::getLogInfo, args("log_level"),
       "get the current bitmask of which parts of the log message will be printed for a given log level")
  ;
 
  void (LogPythonInterface::*addLogConsole)(bool) = &LogPythonInterface::addLogConsole;
 
  //Interface the Interface class :)
  class_<LogPythonInterface, std::shared_ptr<LogPythonInterface>, boost::noncopyable>("LogPythonInterface", R"(
Logging configuration (for messages generated from C++ or Python), available as a global `basf2.logging` object in Python. See also `basf2.set_log_level()` and `basf2.set_debug_level()`.
 
This class exposes a object called `logging <basf2.logging>` to the python interface. With
this object it is possible to set all properties of the logging system
directly in the steering file in a consistent manner This class also
exposes the `LogConfig` class as well as the `LogLevel`
and `LogInfo` enums to make setting of properties more transparent
by using the names and not just the values.  To set or get the log level,
one can simply do:
 
>>> logging.log_level = LogLevel.FATAL
>>> print("Logging level set to", logging.log_level)
FATAL
 
This module also allows to send log messages directly from python to ease
consistent error reporting throughout the framework
 
>>> B2WARNING("This is a warning message")
 
.. seealso::
 
   For all features, see :download:`b2logging.py </framework/examples/b2logging.py>`)")
  .add_property("log_level",  &LogPythonInterface::getLogLevel,  &LogPythonInterface::setLogLevel, R"DOC(
Attribute for setting/getting the current `log level <basf2.LogLevel>`.
Messages with a lower level are ignored.
 
.. warning: Message with a level of `ERROR <LogLevel.ERROR>` or higher will always be shown and cannot be silenced.
)DOC")
  .add_property("debug_level", &LogPythonInterface::getDebugLevel, &LogPythonInterface::setDebugLevel,
                "Attribute for getting/setting the debug level. If debug messages are enabled, their level needs to be at least this high to be printed. Defaults to 100.")
  .add_property("abort_level", &LogPythonInterface::getAbortLevel, &LogPythonInterface::setAbortLevel,
                "Attribute for setting/getting the `log level <basf2.LogLevel>` at which to abort processing. Defaults to `FATAL <LogLevel.FATAL>` but can be set to a lower level in rare cases.")
  .add_property("max_repetitions", &LogPythonInterface::getMaxMessageRepetitions, &LogPythonInterface::setMaxMessageRepetitions, R"DOC(
Set the maximum amount of times log messages with the same level and message text
(excluding variables) will be repeated before it is suppressed. Suppressed messages
will still be counted but not shown for the remainder of the processing.
 
This affects messages with the same text but different ref:`logging_logvariables`.
If the same log message is repeated frequently with different variables all of
these will be suppressed after the given amount of repetitions.
 
.. versionadded:: release-05-00-00
)DOC")
 
  .def("set_package", &LogPythonInterface::setPackageLogConfig, args("package", "config"),
       "Set `basf2.LogConfig` for given package, see also `package() <basf2.LogPythonInterface.package>`.")
  .def("package", &LogPythonInterface::getPackageLogConfig, return_value_policy<reference_existing_object>(), args("package"),
       R"(Get the `LogConfig` for given package to set detailed logging pararameters for this package.
 
  >>> logging.package('svd').debug_level = 10
  >>> logging.package('svd').set_info(LogLevel.INFO, LogInfo.LEVEL | LogInfo.MESSAGE | LogInfo.FILE)
      )")
  .def("module", &LogPythonInterface::getModuleLogConfig, return_value_policy<reference_existing_object>(), args("module"),
       R"(Get the `LogConfig` for given package to set detailed logging pararameters for this module.
 
  >>> logging.package('svd').debug_level = 10
  >>> logging.package('svd').set_info(LogLevel.INFO, LogInfo.LEVEL | LogInfo.MESSAGE | LogInfo.FILE)
      )")
  .def("set_info", &LogPythonInterface::setLogInfo, args("log_level", "log_info"),
       R"DOCSTRING(Set info to print for given log level. Should be an OR combination of `basf2.LogInfo` constants.
As an example, to show only the level and text for all debug messages one could use
 
>>> basf2.logging.set_info(basf2.LogLevel.DEBUG, basf2.LogInfo.LEVEL | basf2.LogInfo.MESSAGE)
 
Parameters:
  log_level (LogLevel): log level for which to set the display info
  log_info (int): Bitmask of `basf2.LogInfo` constants.)DOCSTRING")
  .def("get_info", &LogPythonInterface::getLogInfo, args("log_level"), "Get info to print for given log level.\n\n"
       "Parameters:\n  log_level (basf2.LogLevel): Log level for which to get the display info")
  .def("add_file", &LogPythonInterface::addLogFile, (bp::arg("filename"), bp::arg("append") = false),
       R"DOCSTRING(Write log output to given file. (In addition to existing outputs)\n\n"
 
Parameters:
  filename (str): Filename to to write log messages into
  append (bool): If set to True the file will be truncated before writing new messages.)DOCSTRING")
  .def("add_console", addLogConsole,
       addLogConsole_overloads(args("enable_color"), "Write log output to console. (In addition to existing outputs). "
                               "If ``enable_color`` is not specified color will be enabled if supported"))
  .def("add_json", &LogPythonInterface::addLogJSON, (bp::arg("complete_info") = false), R"DOCSTRING(
Write log output to console, but format log messages as json objects for
simplified parsing by other tools.  Each log message will be printed as a one
line JSON object.
 
.. versionadded:: release-03-00-00
 
Parameters:
   complete_info (bool): If this is set to True the complete log information is printed regardless of the `LogInfo` setting.
 
See Also:
   `add_console()`, `set_info()`
)DOCSTRING")
  .def("add_udp", &LogPythonInterface::addLogUDP, (bp::arg("hostname"), bp::arg("port")), R"DOCSTRING(
    Send the log output as a JSON object to the given hostname and port via UDP.
 
.. versionadded:: release-04-00-00
 
Parameters:
   hostname (str): The hostname to send the message to. If it can not be resolved, an exception will be thrown.
   port (int): The port on the host to send the message via UDP.
 
See Also:
   `add_json()`
)DOCSTRING")
  .def("terminal_supports_colors", &terminalSupportsColors, "Returns true if the terminal supports colored output")
  .staticmethod("terminal_supports_colors")
  .def("reset", &LogPythonInterface::reset, "Remove all configured logging outputs. "
       "You can then configure your own via `add_file() <basf2.LogPythonInterface.add_file>` "
       "or `add_console() <basf2.LogPythonInterface.add_console>`")
  .def("zero_counters", &LogPythonInterface::zeroCounters, "Reset the per-level message counters.")
  .def_readonly("log_stats", &LogPythonInterface::getLogStatistics, "Returns dictionary with message counters.")
  .def("enable_summary", &LogPythonInterface::enableErrorSummary, args("on"),
       "Enable or disable the error summary printed at the end of processing. "
       "Expects one argument whether or not the summary should be shown")
  .add_property("enable_python_logging",  &LogPythonInterface::getPythonLoggingEnabled,
                &LogPythonInterface::setPythonLoggingEnabled, R"DOCSTRING(
Enable or disable logging via python. If this is set to true than log messages
will be sent via `sys.stdout`. This is probably slightly slower but is useful
when running in jupyter notebooks or when trying to redirect stdout in python
to a buffer. This setting affects all log connections to the
console.
 
.. versionadded:: release-03-00-00)DOCSTRING")
  .add_property("enable_escape_newlines", &LogPythonInterface::getEscapeNewlinesEnabled,
                &LogPythonInterface::setEscapeNewlinesEnabled, R"DOCSTRING(
Enable or disable escaping of newlines in log messages to the console. If this
is set to true than any newline character in log messages printed to the console
will be replaced by a "\n" to ensure that every log messages fits exactly on one line.
 
.. versionadded:: release-04-02-00)DOCSTRING")
  ;
 
  //Expose Logging object
  std::shared_ptr<LogPythonInterface> initguard{new LogPythonInterface()};
  scope().attr("logging") = initguard;
 
  //Add all the logging functions. To handle arbitrary keyword arguments we add
  //them as raw functions. However it seems setting the docstring needs to be
  //done manually in this case. So create function objects, add to namespace,
  //set docstring ...
 
  const std::string common_doc = R"DOCSTRING(
All additional positional arguments are converted to strings and concatenated
to the log message. All keyword arguments are added to the function as
:ref:`logging_logvariables`.)DOCSTRING";
 
  auto logDebug = raw_function(&LogPythonInterface::logDebug);
  def("B2DEBUG", logDebug);
  setattr(logDebug, "__doc__", "B2DEBUG(debugLevel, message, *args, **kwargs)\n\n"
          "Print a `DEBUG <basf2.LogLevel.DEBUG>` message. "
          "The first argument is the `debug_level <basf2.LogLevel.DEBUG>`. " +
          common_doc);
 
  auto logInfo = raw_function(&LogPythonInterface::logInfo);
  def("B2INFO", logInfo);
  setattr(logInfo, "__doc__", "B2INFO(message, *args, **kwargs)\n\n"
          "Print a `INFO <basf2.LogLevel.INFO>` message. " + common_doc);
 
  auto logResult = raw_function(&LogPythonInterface::logResult);
  def("B2RESULT", logResult);

getAbortLevel()

LogConfig::ELogLevel getAbortLevel

(

)

Get the abort level.

Returns

The abort level

Definition at line 70 of file LogPythonInterface.cc.

{
  return LogSystem::Instance().getLogConfig()->getAbortLevel();
}

getDebugLevel()

int getDebugLevel

(

)

Get the debug level.

Returns

The debug level

Definition at line 75 of file LogPythonInterface.cc.

{
  return LogSystem::Instance().getLogConfig()->getDebugLevel();
}

getEscapeNewlinesEnabled()

bool getEscapeNewlinesEnabled

(

)

const

Get flag if newlines in log messages to console should be replaced by '
'`.

Definition at line 155 of file LogPythonInterface.cc.

{
  return LogConnectionConsole::getEscapeNewlinesEnabled();
}

getLogInfo()

int getLogInfo

(

LogConfig::ELogLevel

level

)

Get the printed log information for the given level.

Parameters

level

The log level

Returns

The log information that should be printed (see LogConfig::ELogInfo)

Definition at line 80 of file LogPythonInterface.cc.

{
  return LogSystem::Instance().getLogConfig()->getLogInfo(level);
}

getLogLevel()

LogConfig::ELogLevel getLogLevel

(

)

Get the log level.

Returns

The log level

Definition at line 65 of file LogPythonInterface.cc.

{
  return LogSystem::Instance().getLogConfig()->getLogLevel();
}

getLogStatistics()

dict getLogStatistics

(

)

return dict with log statistics

Return dict containing message counters.

Definition at line 161 of file LogPythonInterface.cc.

{
  dict returnDict;
  const LogSystem& logSys = LogSystem::Instance();
  for (int iLevel = 0; iLevel < LogConfig::c_Default; ++iLevel) {
    auto logLevel = static_cast<LogConfig::ELogLevel>(iLevel);
    returnDict[logLevel] = logSys.getMessageCounter(logLevel);
  }
  return returnDict;
}

getMaxMessageRepetitions()

unsigned getMaxMessageRepetitions

(

)

const

Get maximum number of repetitions before silencing "identical" log messages.

Identity only checks for log level and message content (excluding variables)

Definition at line 95 of file LogPythonInterface.cc.

{
  return LogSystem::Instance().getMaxMessageRepetitions();
}

getModuleLogConfig()

LogConfig & getModuleLogConfig

(

const std::string &

module

)

Get the LogConfig for the given module.

Parameters

module

The module name

Returns

The log configuration object

Definition at line 90 of file LogPythonInterface.cc.

{
  return LogSystem::Instance().getModuleLogConfig(module);
}

getPackageLogConfig()

LogConfig & getPackageLogConfig

(

const std::string &

package

)

Get the LogConfig for the given package.

Parameters

package

The package name

Returns

The log configuration object

Definition at line 85 of file LogPythonInterface.cc.

{
  return LogSystem::Instance().getPackageLogConfig(package);
}

getPythonLoggingEnabled()

bool getPythonLoggingEnabled

(

)

const

Get flag if logging should be done via python sys.stdout

Definition at line 145 of file LogPythonInterface.cc.

{
  return LogConnectionConsole::getPythonLoggingEnabled();
}

logDebug()

boost::python::object logDebug ( boost::python::tuple args, const boost::python::dict & kwargs )

static

Produce debug message.

Parameters

args	positional arguments, concatenated to form message
kwargs	keyword arguments to be converted to log variables

Definition at line 602 of file LogPythonInterface.cc.

logError()

boost::python::object logError ( boost::python::tuple args, const boost::python::dict & kwargs )

static

Produce error message.

Parameters

args	positional arguments, concatenated to form message
kwargs	keyword arguments to be converted to log variables

Definition at line 634 of file LogPythonInterface.cc.

logFatal()

boost::python::object logFatal ( boost::python::tuple args, const boost::python::dict & kwargs )

static

Produce fatal message.

Parameters

args	positional arguments, concatenated to form message
kwargs	keyword arguments to be converted to log variables

Definition at line 640 of file LogPythonInterface.cc.

{
#ifndef LOG_NO_B2RESULT
  dispatchMessage(LogConfig::c_Result, std::move(args), kwargs);
#endif
  return boost::python::object();
}

logInfo()

boost::python::object logInfo ( boost::python::tuple args, const boost::python::dict & kwargs )

static

Produce info message.

Parameters

args	positional arguments, concatenated to form message
kwargs	keyword arguments to be converted to log variables

Definition at line 610 of file LogPythonInterface.cc.

logResult()

boost::python::object logResult ( boost::python::tuple args, const boost::python::dict & kwargs )

static

Produce result message.

Parameters

args	positional arguments, concatenated to form message
kwargs	keyword arguments to be converted to log variables

Definition at line 618 of file LogPythonInterface.cc.

{

logWarning()

boost::python::object logWarning ( boost::python::tuple args, const boost::python::dict & kwargs )

static

Produce warning message.

Parameters

args	positional arguments, concatenated to form message
kwargs	keyword arguments to be converted to log variables

Definition at line 626 of file LogPythonInterface.cc.

{

reset()

void reset

(

)

Reset logging connections.

Definition at line 125 of file LogPythonInterface.cc.

{
  LogSystem::Instance().resetLogConnections();
}

setAbortLevel()

void setAbortLevel

(

LogConfig::ELogLevel

level

)

Set the abort log level.

Parameters

level

The abort log level

Definition at line 40 of file LogPythonInterface.cc.

{
  LogSystem::Instance().getLogConfig()->setAbortLevel(level);
}

setDebugLevel()

void setDebugLevel

(

int

level

)

Set the debug messaging level.

Parameters

level

The debug level

Definition at line 45 of file LogPythonInterface.cc.

{
  LogSystem::Instance().getLogConfig()->setDebugLevel(level);
}

setEscapeNewlinesEnabled()

void setEscapeNewlinesEnabled

(

bool

enabled

)

const

Set flag if newlines in log messages to console should be replaced by '
'.

Definition at line 150 of file LogPythonInterface.cc.

{
  LogConnectionConsole::setEscapeNewlinesEnabled(enabled);
}

setLogInfo()

void setLogInfo	(	LogConfig::ELogLevel	level,
		int	info )

Set the printed log information for the given level.

Parameters

level	The log level
info	The log information that should be printed

Definition at line 50 of file LogPythonInterface.cc.

{
  LogSystem::Instance().getLogConfig()->setLogInfo(level, info);
}

setLogLevel()

void setLogLevel

(

LogConfig::ELogLevel

level

)

Set the log level.

Parameters

level

The log level

Definition at line 31 of file LogPythonInterface.cc.

{
  auto overrideLevel = (LogConfig::ELogLevel)Environment::Instance().getLogLevelOverride();
  if (overrideLevel != LogConfig::c_Default)
    level = overrideLevel;
 
  LogSystem::Instance().getLogConfig()->setLogLevel(level);
}

setMaxMessageRepetitions()

void setMaxMessageRepetitions

(

unsigned

repetitions

)

Set maximum number of repetitions before silencing "identical" log messages.

Identity only checks for log level and message content (excluding variables)

Definition at line 60 of file LogPythonInterface.cc.

{
  LogSystem::Instance().setMaxMessageRepetitions(repetitions);
}

setPackageLogConfig()

void setPackageLogConfig	(	const std::string &	package,
		const LogConfig &	config )

Set LogConfig for a given package.

Parameters

package	The package name
config	The log configuration object

Definition at line 55 of file LogPythonInterface.cc.

{
  LogSystem::Instance().addPackageLogConfig(package, config);
}

setPythonLoggingEnabled()

void setPythonLoggingEnabled

(

bool

enabled

)

const

Set flag if logging should be done via python sys.stdout

Definition at line 140 of file LogPythonInterface.cc.

{
  LogConnectionConsole::setPythonLoggingEnabled(enabled);
}

zeroCounters()

void zeroCounters

(

)

Reset logging counters.

Definition at line 130 of file LogPythonInterface.cc.

{
  LogSystem::Instance().resetMessageCounter();
}

---

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

• framework/pybasf2/include/LogPythonInterface.h
• framework/pybasf2/src/LogPythonInterface.cc