ers Namespace Reference

Namespaces
namespace	format

Classes
struct	AbortStream
	Aborts the current application. More...
class	AnyIssue
class	Configuration
	Manager of ERS streams configuration. More...
class	Context
	An abstract interface to access an Issue context. More...
struct	erstraceStream
struct	ExitStream
	Terminates the current application. More...
class	FilterStream
	Filtering stream implementation. More...
struct	FormattedStandardStream
struct	GlobalLockStream
	Lock for ERS streams. More...
class	InputStream
	ERS Issue input stream interface. More...
class	Issue
	Base class for any user define issue. More...
class	IssueCatcherHandler
	Implements issue catcher lifetime management. More...
class	IssueFactory
	Implements factory pattern for user defined Issues. More...
class	IssueReceiver
	ERS Issue receiver interface. More...
class	IssueRegistrator
class	LocalContext
struct	LocalProcessContext
struct	LockStream
	Lock implementation for an ERS stream. More...
struct	NullStream
	Null stream. More...
class	OutputStream
	ERS abstract output stream interface. More...
class	PluginException
class	PluginManager
class	PyContext
class	PyIssue
class	RemoteContext
struct	RemoteProcessContext
class	RFilterStream
	Filtering stream implementation. More...
struct	Severity
class	SingletonCreator
struct	StandardStream
	Single line, human readable format stream. More...
struct	StandardStreamOutput
class	StreamInitializer
class	StreamManager
	This class manages and provides access to ERS streams. More...
class	ThrottleStream
	Throws issues as exceptions. More...
struct	ThrowStream
	Throws issues as exceptions. More...

Typedefs
typedef Issue	Exception
typedef std::map< std::string, std::string >	string_map
using	inheritance_type = std::list<std::string>

Enumerations
enum	severity {   Debug , Log , Information , Warning ,   Error , Fatal }

Functions
std::ostream &	operator<< (std::ostream &, const ers::Configuration &)
IssueCatcherHandler *	set_issue_catcher (const std::function< void(const ers::Issue &)> &catcher)
int	debug_level ()
void	debug (const Issue &issue, int level=debug_level())
void	error (const Issue &issue)
void	fatal (const Issue &issue)
void	info (const Issue &issue)
void	log (const Issue &issue)
int	verbosity_level ()
void	warning (const Issue &issue)
int	enable_core_dump ()
void	tokenize (const std::string &text, const std::string &separators, std::vector< std::string > &tokens)
int	read_from_environment (const char *name, int default_value)
const char *	read_from_environment (const char *name, const char *default_value)
std::ostream &	operator<< (std::ostream &, const ers::Issue &)
std::ostream &	operator<< (std::ostream &, const IssueFactory &factory)
	streaming operator
dunedaq::ersschema::Context	to_schema (const Context &c)
dunedaq::ersschema::SimpleIssue	to_schema (const Issue &i)
dunedaq::ersschema::IssueChain	to_schema_chain (const Issue &i)
void	to_schema (const Context &c, dunedaq::ersschema::Context &out)
void	to_schema (const Issue &i, dunedaq::ersschema::SimpleIssue &out)
void	to_schema (const Issue &i, dunedaq::ersschema::IssueChain &out)
severity	parse (const std::string &s, severity &)
Severity	parse (const std::string &s, Severity &)
std::string	to_string (severity s)
std::string	to_string (Severity s)
	Transforms a severity type into the corresponding string.
std::ostream &	operator<< (std::ostream &out, ers::severity severityseverity)
std::ostream &	operator<< (std::ostream &out, const ers::Severity &severityseverity)
std::istream &	operator>> (std::istream &in, ers::severity &severityseverity)
std::istream &	operator>> (std::istream &in, ers::Severity &severityseverity)
std::ostream &	operator<< (std::ostream &, const ers::StreamManager &)
	message (message)
	pydebug (msg, lvl)
	pylog (msg)
	pyinfo (msg)
	pywarning (issue)
	pyerror (issue)
	pyfatal (issue)

Variables
template<class T>
std::mutex	SingletonCreator< T >::s_mutex
template<class T>
T *	SingletonCreator< T >::s_instance

Detailed Description

This is a wrapping namespace for all ERS classes and global functions.

Typedef Documentation

Exception

typedef Issue ers::Exception

Definition at line 50 of file ers.hpp.

inheritance_type

using ers::inheritance_type = std::list<std::string>

Definition at line 54 of file Issue.hpp.

string_map

typedef std::map<std::string, std::string> ers::string_map

Definition at line 52 of file Issue.hpp.

Enumeration Type Documentation

severity

enum ers::severity

Enumerator
Debug
Log
Information
Warning
Error
Fatal

Definition at line 36 of file Severity.hpp.

{
  Debug,
  Log,
  Information,
  Warning,
  Error,
  Fatal
};

Function Documentation

debug()

void ers::debug ( const Issue & issue, int level = debug_level() )

inline

This function sends the issue to the ERS DEBUG stream which corresponds to the given debug level.

Parameters

issue

the issue to be reported \level debug level which will be associated with the reported issue

Definition at line 91 of file ers.hpp.

{
  StreamManager::instance().debug(issue, level);
}

debug_level()

int ers::debug_level ( )

inline

This function returns the current debug level for ERS.

Definition at line 80 of file ers.hpp.

{
  return Configuration::instance().debug_level();
}

enable_core_dump()

int ers::enable_core_dump ( )

inline

Definition at line 156 of file ers.hpp.

{
  rlimit core_limit = { RLIM_INFINITY, RLIM_INFINITY };
  return setrlimit(RLIMIT_CORE, &core_limit);
}

error()

void ers::error ( const Issue & issue )

inline

This function sends the issue to the ERS ERROR stream.

Parameters

issue

the issue to be reported

Definition at line 101 of file ers.hpp.

{
  LocalStream::instance().error(issue);
}

fatal()

void ers::fatal ( const Issue & issue )

inline

This function sends the issue to the ERS FATAL stream.

Parameters

issue

the issue to be reported

Definition at line 111 of file ers.hpp.

{
  LocalStream::instance().fatal(issue);
}

info()

void ers::info ( const Issue & issue )

inline

This function sends the issue to the ERS INFO stream.

Parameters

issue

the issue to be reported

Definition at line 121 of file ers.hpp.

{
  StreamManager::instance().information(issue);
}

log()

void ers::log ( const Issue & issue )

inline

This function sends the issue to the ERS LOG stream.

Parameters

issue

the issue to be reported

Definition at line 131 of file ers.hpp.

{
  StreamManager::instance().log(issue);
}

message()

message

(

message

)

Definition at line 84 of file __init__.py.

def message(message):
    # This class collects information needed for message context
    ct = PyContext(message)
    # Still need to do something about these
    package_name = "erspy"
    type="Warning"
    # Create Context using the ers-python bindings
    rpc = ers.RemoteProcessContext(ct.host_name,ct.process_id,ct.thread_id,ct.cwd,ct.user_id,ct.user_name,ct.application_name)
    rc = ers.RemoteContext(package_name,ct.file_name,ct.line_number,ct.function_name,rpc)
    # Create and return an ers issue
    return ers.AnyIssue(type, rc, message)
 
 
'''Bunch of functions to wrap a text string and inject it as an ers message of different types'''

operator<<() [1/6]

std::ostream & ers::operator<<	(	std::ostream &	out,
		const ers::Configuration &	conf )

Definition at line 59 of file Configuration.cpp.

{
  out << "debug level = " << conf.m_debug_level << " verbosity level = " << conf.m_verbosity_level;
  return out;
}

operator<<() [2/6]

std::ostream & ers::operator<<	(	std::ostream &	out,
		const ers::Issue &	issue )

Standard streaming operator - puts the issue in human readable format into the standard out stream.

Parameters

out	the destination out stream
issue	the Issue to be printed

Definition at line 217 of file Issue.cpp.

{
  return StandardStreamOutput::print(out, issue, ers::verbosity_level());
}

operator<<() [3/6]

std::ostream & ers::operator<<	(	std::ostream &	out,
		const ers::StreamManager &	)

Definition at line 356 of file StreamManager.cpp.

{
  for (short ss = ers::Debug; ss <= ers::Fatal; ++ss) {
    out << (ers::severity)ss << "\t\"" << get_stream_description((ers::severity)ss) << "\"" << std::endl;
  }
  return out;
}

operator<<() [4/6]

std::ostream & ers::operator<<	(	std::ostream &	,
		const IssueFactory &	factory )

streaming operator

operator<<() [5/6]

std::ostream & ers::operator<< ( std::ostream & out, const ers::Severity & severity )

inline

Definition at line 77 of file Severity.hpp.

{
  out << to_string(severity);
  return out;
}

operator<<() [6/6]

std::ostream & ers::operator<< ( std::ostream & out, ers::severity severity )

inline

Definition at line 70 of file Severity.hpp.

{
  out << to_string(severity);
  return out;
}

operator>>() [1/2]

std::istream & ers::operator>> ( std::istream & in, ers::Severity & severity )

inline

Definition at line 94 of file Severity.hpp.

{
  std::string string;
  in >> string;
  parse(string, severity);
  return in;
}

operator>>() [2/2]

std::istream & ers::operator>> ( std::istream & in, ers::severity & severity )

inline

Definition at line 85 of file Severity.hpp.

{
  std::string string;
  in >> string;
  parse(string, severity);
  return in;
}

parse() [1/2]

ers::Severity ers::parse	(	const std::string &	string,
		ers::Severity &	s )

Parses a string and extracts a severity

Parameters

s	the string to parse

Returns

a severity value

Definition at line 75 of file Severity.cpp.

{
  int level = 0;
  ers::severity type;
  std::string::size_type pos = string.find('_');
  if (pos) {
    std::istringstream in(string.substr(pos + 1));
    in >> level;
    ers::parse(string.substr(0, pos), type);
  } else {
    ers::parse(string, type);
  }
  return (s = ers::Severity(type, level));
}

parse() [2/2]

ers::severity ers::parse	(	const std::string &	string,
		ers::severity &	s )

Parses a string and extracts a severity

Parameters

s	the string to parse

Returns

a severity value

Definition at line 60 of file Severity.cpp.

{
  for (short ss = ers::Debug; ss <= ers::Fatal; ++ss) {
    if (string == SeverityNames[ss]) {
      return (s = (ers::severity)ss);
    }
  }
  throw ers::BadSeverity(ERS_HERE, string);
}

pydebug()

pydebug	(		msg,
			lvl )

Definition at line 98 of file __init__.py.

def pydebug( msg, lvl ):
    "sends msg to the debug stream"
    ers.debug( isinstance( msg, ers.AnyIssue ) and msg or message( msg ), lvl )
 

pyerror()

pyerror

(

issue

)

Definition at line 121 of file __init__.py.

def pyerror( issue ):
    "sends issue to the error stream"
    assert isinstance(issue, ers.AnyIssue), \
            'Only an instance of ers.Issue sub-class can be sent to the ers.error stream'
    ers.error( issue )
 

pyfatal()

pyfatal

(

issue

)

Definition at line 127 of file __init__.py.

def pyfatal( issue ):
    "sends issue to the fatal stream"
    assert isinstance(issue,ers.AnyIssue), \
            'Only an instance of ers.Issue sub-class can be sent to the ers.fatal stream'
    ers.fatal( issue )

pyinfo()

pyinfo

(

msg

)

Definition at line 106 of file __init__.py.

def pyinfo( msg ):
    "sends msg to the information stream"
    ers.info( isinstance( msg, ers.AnyIssue ) and msg or message( msg ) )
 
'''These just inject an issue into the more serious streams.
   The only thing these add over just calling the bound ers function directly is that they
   warn you if you use the wrong type of argument.
   Mainly here because the old ers.py had them, and they provide a consistency of interface
   rather than forcing the user to use these calls for some things and direct ers calls for others'''

pylog()

pylog

(

msg

)

Definition at line 102 of file __init__.py.

def pylog( msg ):
    "sends msg to the log stream"
    ers.log( isinstance( msg, ers.AnyIssue ) and msg or message( msg ) )
 

pywarning()

pywarning

(

issue

)

Definition at line 115 of file __init__.py.

def pywarning( issue ):
    "sends issue to the warning stream"
    assert isinstance(issue,ers.AnyIssue), \
            'Only an instance of ers.Issue sub-class can be sent to the ers.warning stream'
    ers.warning( issue )
 

read_from_environment() [1/2]

const char * ers::read_from_environment	(	const char *	name,
		const char *	default_value )

Definition at line 46 of file Util.cpp.

{
  const char* env = ::getenv(name);
  return (env ? env : default_value);
}

read_from_environment() [2/2]

int ers::read_from_environment	(	const char *	name,
		int	default_value )

Definition at line 33 of file Util.cpp.

{
  int value = default_value;
  const char* env = ::getenv(name);
  if (env) {
    if (sscanf(env, "%d", &value) != 1) {
      ERS_INTERNAL_ERROR("Wrong value \"" << env << "\" is given for the \"" << name << "\" environment")
    }
  }
  return value;
}

set_issue_catcher()

ers::IssueCatcherHandler * ers::LocalStream::set_issue_catcher ( const std::function< void(const ers::Issue &)> & catcher )

inline

This function sets up the local issue handler function. This function will be executed in the context
of dedicated thread which will be created as a result of this call. All the issues which are reported
via the ers::error, ers::fatal and ers::warning functions will be forwarded to this thread.
\param issue the issue to be reported
\return pointer to the handler object, which allows to remove the catcher by just destroying this object.
        If an applications ignores this return value there will no way of de installing the issue

catcher.

Exceptions

ers::IssueCatcherAlreadySet

for safety reasons local issue handler can be set only once

See also

ers::error()

ers::fatal()

ers::warning()

Definition at line 71 of file ers.hpp.

{
  return LocalStream::instance().set_issue_catcher(catcher);
}

to_schema() [1/5]

dunedaq::ersschema::Context ers::to_schema

(

const Context &

c

)

Definition at line 5 of file Schema.cpp.

{
 
  dunedaq::ersschema::Context out;
  to_schema(c, out);
  return out;
}

to_schema() [2/5]

void ers::to_schema	(	const Context &	c,
		dunedaq::ersschema::Context &	out )

Definition at line 32 of file Schema.cpp.

{
 
  out.set_cwd(c.cwd());
  out.set_file_name(c.file_name());
  out.set_function_name(c.function_name());
  out.set_host_name(c.host_name());
  out.set_line_number(c.line_number());
  out.set_package_name(c.package_name());
 
  out.set_process_id(c.process_id());
  out.set_thread_id(c.thread_id());
  out.set_user_id(c.user_id());
  out.set_user_name(c.user_name());
  out.set_application_name(c.application_name());
}

to_schema() [3/5]

dunedaq::ersschema::SimpleIssue ers::to_schema

(

const Issue &

i

)

Definition at line 14 of file Schema.cpp.

{
 
  dunedaq::ersschema::SimpleIssue out;
  to_schema(i, out);
  return out;
}

to_schema() [4/5]

void ers::to_schema	(	const Issue &	i,
		dunedaq::ersschema::IssueChain &	out )

Definition at line 76 of file Schema.cpp.

{
 
  (*out.mutable_final()) = to_schema(i);
 
  auto cause_ptr = i.cause();
 
  while (cause_ptr) {
    auto ptr = out.add_causes();
    to_schema(*cause_ptr, *ptr);
    ptr->set_severity(ers::to_string(i.severity())); // severity is forced to be the same as the top issue
    cause_ptr = cause_ptr->cause();
  }
}

to_schema() [5/5]

void ers::to_schema	(	const Issue &	i,
		dunedaq::ersschema::SimpleIssue &	out )

Definition at line 50 of file Schema.cpp.

{
 
  auto c = to_schema(i.context());
 
  (*out.mutable_context()) = c;
 
  out.set_name(i.get_class_name());
 
  auto inheritance = i.get_class_inheritance();
  for (auto& c : inheritance) {
    out.add_inheritance(c);
  }
 
  out.set_message(i.message());
  out.set_severity(ers::to_string(i.severity()));
  auto time = std::chrono::duration_cast<std::chrono::nanoseconds>(i.ptime().time_since_epoch()).count();
  out.set_time(time);
 
  auto& params = (*out.mutable_parameters());
  for (auto p : i.parameters()) {
    params[p.first] = p.second;
  }
}

to_schema_chain()

dunedaq::ersschema::IssueChain ers::to_schema_chain

(

const Issue &

i

)

Definition at line 23 of file Schema.cpp.

{
 
  dunedaq::ersschema::IssueChain out;
  to_schema(i, out);
  return out;
}

to_string() [1/2]

std::string ers::to_string

(

ers::Severity

severity

)

Transforms a severity type into the corresponding string.

Parameters

s

severity

Returns

pointer to string with associated text

Definition at line 43 of file Severity.cpp.

{
  assert(ers::Debug <= severity && severity <= ers::Fatal);
 
  if (severity.type == ers::Debug) {
    std::ostringstream out;
    out << SeverityNames[severity] << "_" << severity.rank;
    return out.str();
  }
  return SeverityNames[severity.type];
}

to_string() [2/2]

std::string ers::to_string

(

severity

s

)

tokenize()

void ers::tokenize	(	const std::string &	text,
		const std::string &	separators,
		std::vector< std::string > &	tokens )

Definition at line 18 of file Util.cpp.

{
  std::string::size_type start_p, end_p;
  start_p = 0;
  do {
    end_p = text.find_first_of(separators, start_p);
    if (end_p == std::string::npos) {
      end_p = text.length();
    }
    result.push_back(text.substr(start_p, end_p - start_p));
    start_p = text.find_first_not_of(separators, end_p);
  } while (start_p != std::string::npos);
}

verbosity_level()

int ers::verbosity_level ( )

inline

This function returns the current verbosity level for ERS.

Definition at line 140 of file ers.hpp.

{
  return Configuration::instance().verbosity_level();
}

warning()

void ers::warning ( const Issue & issue )

inline

This function sends the issue to the ERS WARNING stream.

Parameters

issue

the issue to be reported

Definition at line 150 of file ers.hpp.

{
  LocalStream::instance().warning(issue);
}

Variable Documentation

SingletonCreator< T >::s_instance

template<class T>

T* ers::SingletonCreator< T >::s_instance

Definition at line 58 of file SingletonCreator.hpp.

SingletonCreator< T >::s_mutex

template<class T>

std::mutex ers::SingletonCreator< T >::s_mutex

Definition at line 55 of file SingletonCreator.hpp.