IssueLogger Class Reference

#include <IssueLogger.h>

Inheritance diagram for IssueLogger:

[legend]

Collaboration diagram for IssueLogger:

[legend]

List of all members.

Detailed Description

Definition at line 17 of file IssueLogger.h.


Public Member Functions
virtual StatusCode	initialize ()
	Initialization (from CONFIGURED to INITIALIZED).
virtual StatusCode	reinitialize ()
	Initialization (from INITIALIZED or RUNNING to INITIALIZED, via CONFIGURED).
virtual StatusCode	finalize ()
	Finalize (from INITIALIZED to CONFIGURED).
virtual StatusCode	queryInterface (const InterfaceID &riid, void **ppvInterface)
	Query interfaces of Interface.
	IssueLogger (const std::string &name, ISvcLocator *svc)
void	report (IssueSeverity::Level level, const std::string &msg, const std::string &origin)
void	report (const IssueSeverity &err)
Protected Member Functions
virtual	~IssueLogger ()
Private Member Functions
StatusCode	connect (const std::string &)
void	getTraceBack (std::string &stack)
MSG::Level	sevToMsg (IssueSeverity::Level &lev)
IssueSeverity::Level	msgToSev (MSG::Level &lev)
void	setupDefaultLogger ()
void	setupLevels (Property &prop)
void	setupStreams (Property &prop)
Private Attributes
StringArrayProperty	m_outputfile
StringProperty	m_reportLevelS
StringProperty	m_traceLevelS
BooleanProperty	m_showTime
IssueSeverity::Level	m_reportLevel
IssueSeverity::Level	m_traceLevel
StreamLogger *	m_logger [IssueSeverity::NUM_LEVELS]
boost::function< void(const std::string &)>	m_log [IssueSeverity::NUM_LEVELS]
std::map< MSG::Level, IssueSeverity::Level >	m_msgSevMap
std::map< IssueSeverity::Level, MSG::Level >	m_sevMsgMap
std::map< IssueSeverity::Level, std::string >	m_levelTrans
std::map< std::string, IssueSeverity::Level >	m_levelSTrans
Friends
class	SvcFactory< IssueLogger >

Constructor & Destructor Documentation

IssueLogger::IssueLogger	(	const std::string &	name,
		ISvcLocator *	svc
	)

Definition at line 32 of file IssueLogger.cpp.

00033   : Service(name, svc) {
00034 
00035   declareProperty ("Output", m_outputfile );
00036   declareProperty ("ReportLevel", m_reportLevelS="WARNING");
00037   declareProperty ("TracebackLevel", m_traceLevelS="ERROR");
00038   declareProperty ("ShowTime", m_showTime=false);
00039 
00040   m_reportLevelS.declareUpdateHandler(&IssueLogger::setupLevels,this);
00041   m_traceLevelS.declareUpdateHandler(&IssueLogger::setupLevels,this);
00042   m_outputfile.declareUpdateHandler(&IssueLogger::setupStreams,this);
00043 
00044   m_reportLevel = IssueSeverity::WARNING;
00045   m_traceLevel  = IssueSeverity::ERROR;
00046 
00047   for (int i=0; i<IssueSeverity::NUM_LEVELS; ++i) {
00048     m_logger[i] = 0;
00049   }
00050 
00051   m_msgSevMap[MSG::NIL]     = IssueSeverity::NIL;
00052   m_msgSevMap[MSG::VERBOSE] = IssueSeverity::VERBOSE;
00053   m_msgSevMap[MSG::DEBUG]   = IssueSeverity::DEBUG;
00054   m_msgSevMap[MSG::INFO]    = IssueSeverity::INFO;
00055   m_msgSevMap[MSG::WARNING] = IssueSeverity::WARNING;
00056   m_msgSevMap[MSG::ERROR]   = IssueSeverity::ERROR;
00057   m_msgSevMap[MSG::FATAL]   = IssueSeverity::FATAL;
00058   m_msgSevMap[MSG::ALWAYS]  = IssueSeverity::ALWAYS;
00059 
00060   m_sevMsgMap[IssueSeverity::NIL]           = MSG::NIL;
00061   m_sevMsgMap[IssueSeverity::VERBOSE]       = MSG::VERBOSE;
00062   m_sevMsgMap[IssueSeverity::DEBUG]         = MSG::DEBUG;
00063   m_sevMsgMap[IssueSeverity::DEBUG1]        = MSG::DEBUG;
00064   m_sevMsgMap[IssueSeverity::DEBUG2]        = MSG::DEBUG;
00065   m_sevMsgMap[IssueSeverity::DEBUG3]        = MSG::DEBUG;
00066   m_sevMsgMap[IssueSeverity::INFO]          = MSG::INFO;
00067   m_sevMsgMap[IssueSeverity::WARNING]       = MSG::WARNING;
00068   m_sevMsgMap[IssueSeverity::RECOVERABLE]   = MSG::ERROR;
00069   m_sevMsgMap[IssueSeverity::ERROR]         = MSG::ERROR;
00070   m_sevMsgMap[IssueSeverity::FATAL]         = MSG::FATAL;
00071   m_sevMsgMap[IssueSeverity::ALWAYS]        = MSG::ALWAYS;
00072 
00073   m_levelTrans[IssueSeverity::VERBOSE]     = "VERBOSE";
00074   m_levelTrans[IssueSeverity::DEBUG]       = "DEBUG";
00075   m_levelTrans[IssueSeverity::DEBUG1]      = "DEBUG1";
00076   m_levelTrans[IssueSeverity::DEBUG2]      = "DEBUG2";
00077   m_levelTrans[IssueSeverity::DEBUG3]      = "DEBUG3";
00078   m_levelTrans[IssueSeverity::INFO]        = "INFO";
00079   m_levelTrans[IssueSeverity::WARNING]     = "WARNING";
00080   m_levelTrans[IssueSeverity::RECOVERABLE] = "RECOVERABLE";
00081   m_levelTrans[IssueSeverity::ERROR]       = "ERROR";
00082   m_levelTrans[IssueSeverity::FATAL]       = "FATAL";
00083   m_levelTrans[IssueSeverity::ALWAYS]      = "ALWAYS";
00084 
00085   m_levelSTrans["VERBOSE"]     = IssueSeverity::VERBOSE;
00086   m_levelSTrans["DEBUG"]       = IssueSeverity::DEBUG;
00087   m_levelSTrans["DEBUG1"]      = IssueSeverity::DEBUG1;
00088   m_levelSTrans["DEBUG2"]      = IssueSeverity::DEBUG2;
00089   m_levelSTrans["DEBUG3"]      = IssueSeverity::DEBUG3;
00090   m_levelSTrans["INFO"]        = IssueSeverity::INFO;
00091   m_levelSTrans["WARNING"]     = IssueSeverity::WARNING;
00092   m_levelSTrans["RECOVERABLE"] = IssueSeverity::RECOVERABLE;
00093   m_levelSTrans["ERROR"]       = IssueSeverity::ERROR;
00094   m_levelSTrans["FATAL"]       = IssueSeverity::FATAL;
00095   m_levelSTrans["ALWAYS"]      = IssueSeverity::ALWAYS;
00096 
00097 
00098 }

IssueLogger::~IssueLogger ( ) [protected, virtual]

Definition at line 102 of file IssueLogger.cpp.

00102                           {
00103 
00104 }

Member Function Documentation

StatusCode IssueLogger::initialize ( ) [virtual]

Initialization (from CONFIGURED to INITIALIZED).

Reimplemented from Service.

Definition at line 127 of file IssueLogger.cpp.

00127                         {
00128 
00129   StatusCode st = Service::initialize();
00130   if (st.isFailure()) { return st; }
00131 
00132   setupDefaultLogger();
00133 
00134   return st;
00135 
00136 }

StatusCode IssueLogger::reinitialize ( ) [virtual]

Initialization (from INITIALIZED or RUNNING to INITIALIZED, via CONFIGURED).

Reimplemented from Service.

Definition at line 141 of file IssueLogger.cpp.

00141                           {
00142 
00143   MsgStream log ( msgSvc(), name() );
00144   log << MSG::WARNING << "reinitialize not implemented" << endreq;
00145 
00146 
00147   return StatusCode::SUCCESS;
00148 
00149 }

StatusCode IssueLogger::finalize ( ) [virtual]

Finalize (from INITIALIZED to CONFIGURED).

Reimplemented from Service.

Definition at line 154 of file IssueLogger.cpp.

00154                       {
00155 
00156   MsgStream log ( msgSvc(), name() );
00157   log << MSG::DEBUG << "IssueLogger::finalize" << endreq;
00158 
00159   for (int i=0; i<IssueSeverity::NUM_LEVELS; ++i) {
00160     IssueSeverity::Level j = IssueSeverity::Level (i);
00161     delete m_logger[j];
00162   }
00163 
00164   return Service::finalize();
00165 }

StatusCode IssueLogger::queryInterface	(	const InterfaceID &	riid,
		void **	ppvUnknown
	)			`[virtual]`

Query interfaces of Interface.

Parameters:

	riid	ID of Interface to be retrieved
	ppvUnknown	Pointer to Location for interface pointer

Reimplemented from Service.

Definition at line 107 of file IssueLogger.cpp.

00108                                                               {
00109   StatusCode sc = StatusCode::FAILURE;
00110   if ( ppvInterface ) {
00111     *ppvInterface = 0;
00112 
00113     if ( IIssueLogger::interfaceID().versionMatch(riid) )    {
00114       *ppvInterface = static_cast<IIssueLogger*>(this);
00115       sc = StatusCode::SUCCESS;
00116       addRef();
00117     }
00118     else
00119       sc = Service::queryInterface( riid, ppvInterface );
00120   }
00121   return sc;
00122 }

void IssueLogger::report	(	IssueSeverity::Level	level,
		const std::string &	msg,
		const std::string &	origin
	)			`[virtual]`

Implements IIssueLogger.

Definition at line 268 of file IssueLogger.cpp.

00269                                           {
00270 
00271   if ( lev < m_reportLevel) return;
00272 
00273   std::string msg = m_levelTrans[lev] + "  " + org + "  \"" + str + "\"";
00274 
00275   if (m_showTime) {
00276     const time_t t = time( 0 );
00277     tm *tt = localtime( &t );
00278 
00279     ostringstream os;
00280     os << (tt->tm_hour < 10 ? "0" : "" ) << tt->tm_hour << ":"
00281        << (tt->tm_min < 10 ? "0" : "" )  << tt->tm_min << ":"
00282        << (tt->tm_sec < 10 ? "0" : "" )  << tt->tm_sec << " "
00283        << tt->tm_year + 1900 << "/"
00284        << (tt->tm_mon < 9 ? "0" : "" )   << tt->tm_mon+1 << "/"
00285        << (tt->tm_mday < 10 ? "0" : "" ) << tt->tm_mday << " "
00286 #ifdef __linux
00287        << tt->tm_zone;
00288 #else
00289        << " " ;
00290 #endif
00291 
00292     msg += " [" + os.str() +"]";
00293 
00294   }
00295 
00296   if (lev >= m_traceLevel) {
00297     std::string stack;
00298     getTraceBack(stack);
00299     msg += "\n" + stack;
00300   }
00301 
00302 
00303   m_log[lev](msg);
00304 
00305 
00306 }

void IssueLogger::report ( const IssueSeverity & err ) [virtual]

Implements IIssueLogger.

Definition at line 313 of file IssueLogger.cpp.

00313                                               {
00314 
00315   report(err.getLevel(), err.getMsg(), err.getOrigin());
00316 
00317 }

StatusCode IssueLogger::connect ( const std::string & ident ) [private]

Definition at line 179 of file IssueLogger.cpp.

00179                                            {
00180 
00181   MsgStream log ( msgSvc(), name() );
00182   Tokenizer tok(true);
00183 
00184   string::size_type loc = ident.find(" ");
00185   string stream = ident.substr(0,loc);
00186 //   typedef std::pair<std::string,std::string>      Prop;
00187 //   std::vector<Prop> props;
00188   string val,VAL,TAG,filename;
00189 
00190   tok.analyse(ident.substr(loc+1,ident.length()), " ", "", "", "=", "'", "'");
00191 
00192   for ( Tokenizer::Items::iterator i = tok.items().begin();
00193         i != tok.items().end(); i++)    {
00194     const std::string& tag = (*i).tag();
00195     TAG = tag;
00196     toupper(TAG);
00197 
00198     val = (*i).value();
00199     VAL = val;
00200     toupper(VAL);
00201 
00202     IssueSeverity::Level level;
00203 
00204     if (TAG == "DEBUG") {
00205       level = IssueSeverity::DEBUG;
00206     } else if ( TAG == "INFO") {
00207       level = IssueSeverity::INFO;
00208     } else if ( TAG == "WARNING") {
00209       level = IssueSeverity::WARNING;
00210     } else if ( TAG == "RECOVERABLE") {
00211       level = IssueSeverity::RECOVERABLE;
00212     } else if ( TAG == "ERROR") {
00213       level = IssueSeverity::ERROR;
00214     } else if ( TAG == "FATAL") {
00215       level = IssueSeverity::FATAL;
00216     } else {
00217       log << MSG::ERROR << "Unknown output level \"" << TAG << "\""
00218           << endreq;
00219       continue;
00220     }
00221 
00222     if (m_logger[level] != 0) {
00223       log << MSG::INFO << "closing stream " << m_logger[level]->name()
00224           << endreq;
00225       delete m_logger[level];
00226       m_logger[level] = 0;
00227     }
00228 
00229     if (val == "MsgSvc") {
00230       m_logger[level] = new StreamLogger(msgSvc(), m_sevMsgMap[level]);
00231       m_log[level] =
00232         boost::bind(&StreamLogger::WriteToMsgSvc, m_logger[level],
00233                     _1);
00234     } else if (val == "STDERR") {
00235       m_logger[level] = new StreamLogger(std::cerr);
00236       m_log[level] =
00237         boost::bind(&StreamLogger::WriteToStream, m_logger[level],
00238                     _1);
00239     } else if (val == "STDOUT") {
00240       m_logger[level] = new StreamLogger(std::cout);
00241       m_log[level] =
00242         boost::bind(&StreamLogger::WriteToStream, m_logger[level],
00243                     _1);
00244     } else { // A file
00245       try {
00246         m_logger[level] = new StreamLogger(val.c_str());
00247       }
00248       catch (std::exception&) {
00249         m_logger[level] = 0;
00250         log << MSG::ERROR << "Unable to open file \"" << VAL
00251             << "\" for writing issues at level " << TAG << endreq;
00252         return StatusCode::FAILURE;
00253       }
00254       m_log[level] =
00255         boost::bind(&StreamLogger::WriteToStream, m_logger[level], _1);
00256     }
00257     log << MSG::DEBUG << "Writing " << m_levelTrans[level]
00258         << " issues to " << m_logger[level]->name() << endreq;
00259 
00260   }
00261 
00262   return StatusCode::SUCCESS;
00263 }

void IssueLogger::getTraceBack ( std::string & stack ) [private]

Definition at line 170 of file IssueLogger.cpp.

00170                                           {
00171   const int depth = 30;
00172   const int offset = 5;
00173   System::backTrace(stack, depth, offset);
00174 }

MSG::Level IssueLogger::sevToMsg ( IssueSeverity::Level & lev ) [private]

IssueSeverity::Level IssueLogger::msgToSev ( MSG::Level & lev ) [private]

void IssueLogger::setupDefaultLogger ( ) [private]

Definition at line 394 of file IssueLogger.cpp.

00394                                 {
00395   for (int i=1; i<IssueSeverity::NUM_LEVELS; ++i) {
00396     if (m_logger[i] == 0) {
00397       // default: dump to msgSvc
00398       IssueSeverity::Level j = IssueSeverity::Level (i);
00399 
00400       m_logger[j] = new StreamLogger(msgSvc(), m_sevMsgMap[j]);
00401       m_log[j] = boost::bind(&StreamLogger::WriteToMsgSvc, m_logger[j],
00402                              _1);
00403 
00404       MsgStream log ( msgSvc(), name() );
00405       log << MSG::DEBUG << "Writing " << m_levelTrans[j]
00406           << " issues to " << m_logger[j]->name() << endreq;
00407 
00408     }
00409   }
00410 }

void IssueLogger::setupLevels ( Property & prop ) [private]

Definition at line 322 of file IssueLogger.cpp.

00322                                        {
00323 
00324 
00325   StringProperty *sap = dynamic_cast<StringProperty*> (&prop);
00326   if (sap == 0) {
00327     MsgStream log ( msgSvc(), name() );
00328     log << MSG::ERROR << "Could not convert " << prop.name()
00329         << "to a StringProperty (which it should be!)" << endreq;
00330     return;
00331   }
00332 
00333   std::string val = sap->value();
00334 
00335   if (prop.name() == "ReportLevel") {
00336     if (m_levelSTrans.find(val) == m_levelSTrans.end()) {
00337       MsgStream log ( msgSvc(), name() );
00338       log << MSG::ERROR
00339           << "Option ReportLevel: unknown Issue Severity level \""
00340           << val << "\". Setting it WARNING" << endreq;
00341       m_reportLevel = IssueSeverity::WARNING;
00342       return;
00343     } else {
00344       m_reportLevel = m_levelSTrans[m_reportLevelS];
00345     }
00346   } else if (prop.name() == "TracebackLevel") {
00347     if (m_levelSTrans.find(val) == m_levelSTrans.end()) {
00348       MsgStream log ( msgSvc(), name() );
00349       log << MSG::ERROR
00350           << "Option TracebackLevel: unknown Issue Severity level \""
00351           << val << "\". Setting it to ERROR" << endreq;
00352       m_traceLevel = IssueSeverity::ERROR;
00353       return;
00354     } else {
00355       m_traceLevel = m_levelSTrans[m_traceLevelS];
00356     }
00357   } else {
00358       MsgStream log ( msgSvc(), name() );
00359       log << MSG::ERROR << "setting up unknown property \"" << prop.name()
00360           << "\"" << endreq;
00361       return;
00362   }
00363 
00364 }

void IssueLogger::setupStreams ( Property & prop ) [private]

Definition at line 369 of file IssueLogger.cpp.

00369                                         {
00370 
00371   StringArrayProperty *sap = dynamic_cast<StringArrayProperty*>( &prop );
00372   if (sap == 0) {
00373     MsgStream log ( msgSvc(), name() );
00374     log << MSG::ERROR << "Could not convert " << prop.name()
00375         << "to a StringArrayProperty (which it should be!)" << endreq;
00376     return;
00377   }
00378 
00379   vector<string>::const_iterator itr;
00380   for (itr = sap->value().begin(); itr != sap->value().end(); ++itr) {
00381     if (connect(*itr).isFailure()) {
00382       MsgStream log ( msgSvc(), name() );
00383       log << MSG::ERROR << "Could not setup stream " << *itr << endreq;
00384     }
00385   }
00386 
00387   return;
00388 
00389 }

Friends And Related Function Documentation

friend class SvcFactory< IssueLogger > [friend]

Definition at line 20 of file IssueLogger.h.

Member Data Documentation

StringArrayProperty IssueLogger::m_outputfile [private]

Definition at line 43 of file IssueLogger.h.

StringProperty IssueLogger::m_reportLevelS [private]

Definition at line 44 of file IssueLogger.h.

StringProperty IssueLogger::m_traceLevelS [private]

Definition at line 44 of file IssueLogger.h.

BooleanProperty IssueLogger::m_showTime [private]

Definition at line 45 of file IssueLogger.h.

IssueSeverity::Level IssueLogger::m_reportLevel [private]

Definition at line 47 of file IssueLogger.h.

IssueSeverity::Level IssueLogger::m_traceLevel [private]

Definition at line 47 of file IssueLogger.h.

StreamLogger* IssueLogger::m_logger[IssueSeverity::NUM_LEVELS] [private]

Definition at line 49 of file IssueLogger.h.

boost::function<void (const std::string&)> IssueLogger::m_log[IssueSeverity::NUM_LEVELS] [private]

Definition at line 50 of file IssueLogger.h.

std::map<MSG::Level, IssueSeverity::Level> IssueLogger::m_msgSevMap [private]

Definition at line 52 of file IssueLogger.h.

std::map<IssueSeverity::Level, MSG::Level> IssueLogger::m_sevMsgMap [private]

Definition at line 53 of file IssueLogger.h.

std::map<IssueSeverity::Level, std::string> IssueLogger::m_levelTrans [private]

Definition at line 54 of file IssueLogger.h.

std::map<std::string, IssueSeverity::Level> IssueLogger::m_levelSTrans [private]

Definition at line 55 of file IssueLogger.h.

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

/afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v20r3/GaudiSvc/src/IssueLogger/IssueLogger.h
/afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v20r3/GaudiSvc/src/IssueLogger/IssueLogger.cpp

	Gaudi Framework, version v20r3
	Generated: 24 Nov 2008

Gaudi Framework, version v20r3

IssueLogger Class Reference

Detailed Description

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation