StRoot: StStarLogger/StLoggerManager.cxx Source File

00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 
00011 //                                                                       //
00013 #include <stdlib.h>
00014 
00015 #ifdef __ROOT__
00016 #include "TROOT.h"
00017 #include "TSystem.h"
00018 #include "TString.h"
00019 #include "TError.h"
00020 #include "TEnv.h"
00021 #include "TVirtualMutex.h"
00022 #endif
00023 
00024 #ifndef  _NO_IMPLEMENTATION_
00025 #define  _NO_IMPLEMENTATION_   {       \
00026    const char *text = __FUNCTION__;    \
00027    NDC::push(_T("NO IMPLEMENTATION")); \
00028    PrintLogger(text,'D',"");           \
00029    NDC::pop();                         \
00030 }
00031 #endif 
00032 
00033 #include "StLoggerManager.h"
00034 
00035 #include <log4cxx/basicconfigurator.h>
00036 #include <log4cxx/propertyconfigurator.h>
00037 #include <log4cxx/helpers/exception.h>
00038 #include <log4cxx/ndc.h>
00039 #include <log4cxx/consoleappender.h>
00040 #include <log4cxx/patternlayout.h>
00041 #include <log4cxx/layout.h>
00042 #include <log4cxx/xml/domconfigurator.h>
00043 //#include <log4cxx/varia/stringmatchfilter.h>
00044 // #include <log4cxx/varia/denyallfilter.h>
00045 
00046 #include "StStarLogger/StUCMAppender.h"
00047 
00048 using namespace log4cxx;
00049 using namespace log4cxx::helpers;
00050 using namespace log4cxx::spi;
00051 using namespace log4cxx::varia;
00052 using namespace log4cxx::db;
00053 #if (STAR_LOG4CXX_VERSION == 10)
00054    using namespace log4cxx::filter;
00055 #endif
00056 
00057 class  StMessage  {
00058   public: StMessage(){}
00059 };
00060 
00061 log4cxx::LoggerPtr StLoggerManager::fgQALogger;      
00062 log4cxx::LoggerPtr &StLoggerManager::fgUCMLogger = *(new log4cxx::LoggerPtr());    
00063 
00064 const char *StLoggerManager::fgLevels = "FEWIDQU";
00065 #ifdef __ROOT__
00066 //    ROOT Error handling subrotuine
00067 //______________________________________________________________________________
00068 static void Log4cxx4RootErrorHandler(Int_t level, Bool_t abort, const char *location, const char *msg)
00069 {
00070    // This is derived from  the ROOT "default error handler function" TError.cxx
00071    // The default error handler function. It prints the message on stderr and
00072    // if abort is set it aborts the application.
00073 
00074    
00075  //  The level is defined by the current logger level
00076    NDC::push("ROOT");
00077          
00078 #if ROOT_VERSION_CODE >= ROOT_VERSION(5,00,0)
00079 if (gErrorIgnoreLevel == kUnset) {
00080       
00081        R__LOCKGUARD2(gErrorMutex);
00082 #else 
00083        {       
00084 #endif       
00085 
00086       gErrorIgnoreLevel = 0;
00087       if (gEnv) {
00088          TString level = gEnv->GetValue("Root.ErrorIgnoreLevel", "Info");
00089          if (!level.CompareTo("Info",TString::kIgnoreCase))
00090             gErrorIgnoreLevel = kInfo;
00091          else if (!level.CompareTo("Warning",TString::kIgnoreCase))
00092             gErrorIgnoreLevel = kWarning;
00093          else if (!level.CompareTo("Error",TString::kIgnoreCase))
00094             gErrorIgnoreLevel = kError;
00095          else if (!level.CompareTo("Break",TString::kIgnoreCase))
00096             gErrorIgnoreLevel = kBreak;
00097          else if (!level.CompareTo("SysError",TString::kIgnoreCase))
00098             gErrorIgnoreLevel = kSysError;
00099          else if (!level.CompareTo("Fatal",TString::kIgnoreCase))
00100             gErrorIgnoreLevel = kFatal;
00101       }
00102    }
00103 
00104    if (level < gErrorIgnoreLevel)
00105       return;
00106    
00107 
00108    if (level >= kFatal) {
00109         LOG_FATAL << location <<msg << endm;
00110      } else if (level >= kSysError) {
00111         LOG_FATAL << location << " : " << msg << endm;  
00112      } else if (level >= kBreak) {
00113         LOG_FATAL << location << " : " << msg << endm;  
00114      } else if (level >= kError) { 
00115         LOG_ERROR << location << " : " << msg << endm;
00116 //   else if (level >= kWarning)
00117 //        LOG_WARN << location << " : " << msg << endm;
00118      } else if (level >= kInfo) {
00119         LOG_INFO << location << " : " << msg << endm;
00120      }
00121 
00122    if (abort) {
00123       if (gSystem) {
00124          gSystem->StackTrace();
00125          gSystem->Abort();
00126       } else
00127          ::abort();
00128    }
00129    NDC::pop();
00130 }
00131 #endif
00132 //________________________________________
00133 std::ostream& StLoggerManager::OperatorShift(std::ostream& os, StMessage* stm) {
00134 // std::ostream& operator<<(std::ostream& os, StMessage* stm) {
00135   ostrstream &thisStream =  Stream();
00136   if ( (&thisStream == &os) && (stm == endm) ) {
00137     // There was a StMessage terminator
00138      os << ends;
00139      StMessMgr::CurrentMessager()->Print();
00140      os.seekp(0);os<< ends;os.seekp(0);
00141   } else {
00142      assert(0);
00143   }
00144   return os;
00145 }
00146 
00147 //static const char defaultMessType = 'I';
00148 //static char emptyString[] = "";
00149 //static char oOpt[] = "O";
00150 //static char otsOpt[] = "OTS";
00151 //static char eOpt[] = "E";
00152 //static char nullMess[] = "Null message!!!";
00153 
00154 StMessMgr* StLoggerManager::mInstance = 0;
00155 //
00156 // C++ routines:
00157 //_____________________________________________________________________________
00158 #ifdef __ROOT__
00159 ClassImp(StLoggerManager)
00160 #endif
00161 //_____________________________________________________________________________
00162 StLoggerManager::StLoggerManager(const char *loggerName) 
00163                 : StMessMgr(), fCurType(0),fAllowRepeat(-1),fLastRepeatCounter(0),fStarOptionFilter(0)
00164 {
00165 //
00166 // Constructor - only called once when the library is loaded to
00167 // instantiate the global message manager.
00168 //
00169 // Format 
00170 //   %c  - logger name %c{2} = b.c  ( a.b.c. )
00171 //   %d  - date        %d{%H:%M:%S} or %d{%d %b %Y %H:%M:%S}. 
00172 //                      a - short week date name, A - full week date name
00173 //                      b - short month name,     B - full month name  m - month number (1-12)
00174 //                      d - day of the month
00175 //                      H - hours (0-23)          I - hours ( 1 - 12)
00176 //   %F  - the file name where the logging request was issued
00177 //   %l  - location information of the caller which generated the logging event
00178 //   %L  - the line number from where the logging request was issued
00179 //   %m  - the application supplied message associated with the logging event
00180 //   %n  - the platform dependent line separator character or characters
00181 //   %p  - the level(priority) of the logging event
00182 //   %r  - the number of milliseconds elapsed since the start 
00183 //   %x  - the NDC (nested diagnostic context) 
00184 //
00185 //   This is essentially the TTCC layout.
00186 //   %-6r [%15.15t] %-5p %30.30c %x - %m
00187 
00188   
00189   unsigned int i;
00190   for (i=0;i<strlen(fgLevels);i++){
00191      fSourceFileNames.push_back("");
00192      fLineNumbers[i] = -1;
00193   }
00194   fLogger   = Logger::getLogger(_T(loggerName));
00195   fDefaultLevel = fLogger->getLevel();
00196 //  fCurType     = new char[ 2];  fCurType[0] = 0; fCurType[1] = 0;
00197   fCurOpt      = new char[32];  fCurOpt [0] = 0; 
00198   SwitchOff("D");
00199   MemoryOn();
00200 }
00201 
00202 //_____________________________________________________________________________
00203 StLoggerManager::~StLoggerManager() {
00204 //
00205 // Destructor - must delete the message listsy
00206 //
00207 
00208   fCurType = 0;
00209   if (fCurOpt) delete [] fCurOpt;  fCurOpt = 0;
00210 
00211   if (StLoggerManager::Instance() == this) {
00212       // DestroyInstance();
00213       gMessMgr = 0;
00214    }
00215 
00216 }
00217 //_____________________________________________________________________________
00218 StMessMgr* StLoggerManager::Instantiate() 
00219 {return StLoggerManager::StarLoggerInit(); }
00220 
00221 //_____________________________________________________________________________
00222 StMessMgr* StLoggerManager::Instantiate(const char *loggerName)
00223 {return StLoggerManager::StarLoggerInit(loggerName); }
00224 
00225 //_____________________________________________________________________________
00226 StMessMgr* StLoggerManager::StarLoggerInit(const char *loggerName) 
00227 {
00228    return  new StLoggerManager(loggerName);
00229 }
00230 //_____________________________________________________________________________
00231 StMessMgr* StLoggerManager::StarLoggerInit() {
00232 //
00233 //   Allows anyone to get a pointer to the single message manager:
00234 //   StLoggerManager::Instance()->(member function)
00235 //
00236   if (!mInstance) {
00237     // BasicConfigurator::configure();
00238     const char *proEnv = 0;
00239 #ifndef __ROOT__
00240     String propertyFile = "log4j.xml";
00241 #else
00242     TString fullPropertyFileName = gEnv->GetValue("Logger.Configuration","log4j.xml");
00243     gSystem->ExpandPathName(fullPropertyFileName);
00244     String propertyFile = (const char*)fullPropertyFileName;
00245     proEnv = gSystem->Getenv("STAR_LOGGER_PROPERTY");
00246 #endif
00247     StarOptionFilterPtr filter;
00248     if (proEnv && proEnv[0] ) propertyFile=proEnv;
00249     if (!gSystem->AccessPathName(propertyFile.c_str())) {
00250        xml::DOMConfigurator::configure(propertyFile);
00251 //             PropertyConfigurator::configure(propertyFile);
00252     } else {       
00253         // BasicConfigurator::configure();
00254        LoggerPtr root = Logger::getRootLogger();
00255        // Add the STAR default appender
00256        ConsoleAppenderPtr appender = new ConsoleAppender(
00257                       new PatternLayout("%-3c{2}:%-5p - %m%n"));
00258 //                    new PatternLayout(PatternLayout::TTCC_CONVERSION_PATTERN)));
00259        appender->setName(_T("defaultAppender"));       
00260        root->addAppender(appender);
00261        //Set the default threashold to be 
00262        root->setLevel(LOG4CXX_LEVEL_INFO);
00263     }
00264     LoggerPtr root = Logger::getRootLogger();
00265 
00266     fgQALogger  = Logger::getLogger("QA");
00267     fgUCMLogger = Logger::getLogger("UCM");
00268 #if 1
00269     // Check the mandatory UCM appender
00270     TString ucmenv = gSystem->Getenv("LOGGING");
00271     if (ucmenv == "UCM" && gSystem->Getenv("JOBINDEX") && gSystem->Getenv("REQUESTID") ) {
00272        StUCMAppenderPtr appender(new StUCMAppender(ucmenv.Data()));
00273        appender->setLayout(new PatternLayout("%m"));
00274        appender->setName(_T("UCM"));       
00275        fgUCMLogger->addAppender(appender);
00276        StringMatchFilterPtr filter(new StringMatchFilter());
00277        filter->setStringToMatch(_T("StageID="));
00278        filter->setAcceptOnMatch(true);
00279        appender->addFilter(filter);
00280        appender->addFilter( DenyAllFilterPtr(new DenyAllFilter));
00281 
00282        //Set the default threashold to be 
00283        fgUCMLogger->setLevel(LOG4CXX_LEVEL_DEBUG);
00284     }
00285 #endif
00286     //Almost all QA messages are on the info level
00287     NDC::push(_T(":"));
00288 
00289     mInstance = StarLoggerInit("BFC");
00290    ((StLoggerManager *)mInstance)->SetStarOptionFilter(filter);
00291     // if (gMessMgr) delete gMessMgr; gMessMgr = 0;
00292     gMessMgr  = mInstance;
00293     // Set the ROOT ErrorHanlding via logger as well
00294     // See: $ROOTSYS/include/TError.h
00295     SetErrorHandler(Log4cxx4RootErrorHandler);
00296 //    Connect(gApplication,"Terminate(Int_t)",mInstance);
00297   }
00298   return mInstance;
00299 }
00300 //______________________________________________________________________________
00301 ostrstream &StLoggerManager::Stream()
00302 {
00303    // return the stream allocated for the particular "fCurType"
00304    // Create the new stream if there was none.
00305    // ( I am too lazy to intreodcue the enumare here :-(()
00306    switch (fCurType)  {
00307       case 'F': return fStreams[0];
00308       case 'E': return fStreams[1];
00309       case 'W': return fStreams[2];
00310       case 'I': return fStreams[3];
00311       case 'D': return fStreams[4];
00312       case 'Q': return fStreams[5];
00313       default:  return fStreams[6];
00314    };
00315 }
00316 
00317 //______________________________________________________________________________
00318 bool  StLoggerManager::isDebugEnabled()  const{ return fLogger->isDebugEnabled(); }
00319 //______________________________________________________________________________
00320 bool  StLoggerManager::isWarnEnabled()   const{ return fLogger->isWarnEnabled(); }
00321 //______________________________________________________________________________
00322 bool  StLoggerManager::isErrorEnabled()  const{ return fLogger->isErrorEnabled(); }
00323 //______________________________________________________________________________
00324 bool  StLoggerManager::isInfoEnabled()   const{ return fLogger->isInfoEnabled(); }
00325 //______________________________________________________________________________
00326 bool  StLoggerManager::isFatalEnabled()  const{ return fLogger->isFatalEnabled(); }
00327 //______________________________________________________________________________
00328 bool  StLoggerManager::isEnabledFor()    const{ return true; /*fLogger->isEnabledFor();*/ }
00329 //______________________________________________________________________________
00330 bool  StLoggerManager::isQAInfoEnabled() const{ return fgQALogger? fgQALogger->isInfoEnabled():false; }
00331 //______________________________________________________________________________
00332 bool  StLoggerManager::isUCMInfoEnabled() const{ return fgUCMLogger? fgUCMLogger->isInfoEnabled():false; }
00333 //_____________________________________________________________________________
00334 ostrstream& StLoggerManager::Message(const char* mess, const char* type,
00335   const char* opt,const char *sourceFileName,int lineNumber) {
00336 //
00337 // Message declarator - creates a new message if mess is not empty,
00338 // otherwise, prepares for << input.
00339 //
00340 //
00341 // Instantiate an StMessage and place on the lists of known messages
00342 // type = 
00343 //   'E' - error
00344 //   'W' - warning
00345 //   'I' - info
00346 //   'D' - debug
00347 //   'Q' - QA 
00348 //   'U' - UCM 
00349 //------------------------------
00350 //
00351 // opt = 
00352 //   'O' - stdout
00353 //   'E' - stderr
00354 //   'S' - skip "St"
00355 //   'P' - plain output no decoration
00356 //   'T' - print timestampt  
00357 //------------------------------
00358   unsigned char typeChar = 'I';
00359   if (type && type[0]) typeChar = type[0];
00360   if (!opt) opt = "";
00361   // size_t messSize = (mess && mess[0]) ? strlen(mess) : 0;
00362 //  *fCurType = typeChar;
00363   fCurType = typeChar;
00364   strcpy(fCurOpt,opt);
00365 //  if (tellp() > 0 ) *this << endm;  // print out the previous line if any
00366   
00367   if (sourceFileName && sourceFileName[0] ) fSourceFileNames[LevelIndex(fCurType)] = sourceFileName;
00368   else fSourceFileNames[LevelIndex(fCurType)].clear();
00369   fLineNumbers[LevelIndex(fCurType)]     = lineNumber;
00370  
00371 //  if (messSize > 0) *this << mess << endm; // print out the previous this message if present
00372 //   return *((StMessMgr*) this);
00373   return Stream();
00374 }
00375 //_____________________________________________________________________________
00376 void StLoggerManager::BuildMessage(const char* mess, unsigned char type,
00377   const char* opt,const char *sourceFileName, int lineNumber) {
00378 //
00379 // Instantiate an StMessage and place on the lists of known messages
00380 // type = 
00381 //   'F' - fatal
00382 //   'E' - error
00383 //   'W' - warning
00384 //   'I' - info
00385 //   'D' - debug
00386 //   'Q' - QA 
00387 //   'U' - UCM 
00388 //------------------------------
00389 //
00390 // opt = 
00391 //   'O' - stdout
00392 //   'E' - stderr
00393 //   'S' - skip "St"
00394 //   'P' - plain output no decoartion
00395 //   'T' - print timestampt  
00396 //------------------------------
00397 
00398      if (!opt) opt = "";
00399      PrintLogger(mess,type,opt,sourceFileName,lineNumber);
00400 }
00401 //_____________________________________________________________________________
00402 void StLoggerManager::PrintLogger(const char* mess, unsigned char type,
00403     const char* opt,const char *sourceFileName, int lineNumber) 
00404 {
00405    if (!opt) opt = "";
00406    unsigned char typeChar = 'I';
00407  //  if (type && type[0]) typeChar = type[0];
00408    if (type) typeChar = type;
00409    if (!(sourceFileName || fSourceFileNames[LevelIndex(typeChar)].empty() ) ) 
00410    {
00411       sourceFileName = fSourceFileNames[LevelIndex(typeChar)].c_str();
00412    }
00413 
00414    if ( lineNumber == -1) 
00415       lineNumber = fLineNumbers[LevelIndex(typeChar)];
00416    bool canPrint = true;
00417    if (fAllowRepeat >= 0 ) {
00418         // compare the current message with the buffered
00419       if ( mess == fLastMessage ) {
00420          fLastRepeatCounter++;
00421          canPrint = (fAllowRepeat >= fLastRepeatCounter);
00422       } else {
00423         fLastRepeatCounter= 0;
00424         fLastMessage = mess;
00425       }
00426    }
00427    if (canPrint) {
00428       if ( (mess == 0) || (mess[0] == 0)) mess = "."; // logger doesn't like the empty messages 
00429       // fprintf(stderr, " **** LOGGER **** %c %s\n", typeChar, mess);
00430       switch (typeChar)  {
00431         case 'F': fLogger->fatal  (_T(mess),LocationInfo(sourceFileName,"",lineNumber)); break;
00432         case 'E': fLogger->error  (_T(mess),LocationInfo(sourceFileName,"",lineNumber)); break;
00433         case 'W': fLogger->warn   (_T(mess),LocationInfo(sourceFileName,"",lineNumber)); break;
00434         case 'I': fLogger->info   (_T(mess),LocationInfo(sourceFileName,"",lineNumber)); break;
00435         case 'D': fLogger->debug  (_T(mess),LocationInfo(sourceFileName,"",lineNumber)); break;
00436         case 'Q': fgQALogger->info(_T(mess),LocationInfo(sourceFileName,"",lineNumber)); break;
00437         case 'U': fgUCMLogger->info(_T(mess),LocationInfo(sourceFileName,"",lineNumber)); break;
00438         default: fLogger->info(_T(mess),LocationInfo(sourceFileName,"",lineNumber));     break;
00439       };
00440    }
00441 //   seekp(0);
00442    if (lineNumber != -1) { // restore the context
00443          NDC::pop();
00444    }
00445 }
00446 //_____________________________________________________________________________
00447 void StLoggerManager::Print() {
00448 //
00449 // Empty the buffer into the current message and print it.
00450 // If not currenty building a message, print the last one created.
00451 //
00452   string message = Stream().str();
00453   BuildMessage(message.c_str(),fCurType,fCurOpt);
00454 }
00455 //_____________________________________________________________________________
00456 int StLoggerManager::PrintList(messVec* list) {
00457 //
00458 // Print a list of messages from a messVec list.
00459 //
00460  _NO_IMPLEMENTATION_;
00461  return -1;
00462 }
00463 //_____________________________________________________________________________
00464 StMessage* StLoggerManager::FindMessage(const char* s1, const char* s2,
00465                const char* s3, const char* s4, messVec* list) {
00466  _NO_IMPLEMENTATION_;
00467  return 0;
00468 }
00469 //_____________________________________________________________________________
00470 messVec* StLoggerManager::FindMessageList(const char* s1, const char* s2,
00471                const char* s3, const char* s4, messVec* list) {
00472  _NO_IMPLEMENTATION_;
00473  return 0;
00474 }
00475 //_____________________________________________________________________________
00476 int StLoggerManager::RemoveMessage(StMessage* mess) {
00477 _NO_IMPLEMENTATION_;
00478  return 0;
00479 }
00480 //_____________________________________________________________________________
00481 void StLoggerManager::Summary(size_t nTerms) {
00482 //
00483 // Output a summary of the messages printed so far.
00484 //   nTerms - number of tokens (text separated by spaces) to use in
00485 //            comparisons between messages (default is 1). Messages are
00486 //            compared only if they are of the same message type, and
00487 //            only the message string (not the message type) is included
00488 //            in the number of tokens compared. For example, Summary(0)
00489 //            would give the number of each type of message with no
00490 //            differentiation based on the message string.
00491 //
00492 _NO_IMPLEMENTATION_;
00493 }
00494 //_____________________________________________________________________________
00495 void StLoggerManager::MemorySummary() {
00496 //
00497 // Output a summary of the memory usage of the message manager so far.
00498 // Loops over all stored messages to calculate message sizes and overhead.
00499 //
00500   _NO_IMPLEMENTATION_;
00501 }
00502 //_____________________________________________________________________________
00503 int StLoggerManager::AddType(const char* type, const char* text) {
00504 //
00505 // Add an additional message type. ListTypes() will return a list of all
00506 // currently defined message types. AddType returns a integer which is zero
00507 // if type has already been defined, otherwise returns the number of types
00508 // defined (including the new one).
00509 //   type - a single character string which will represent the message type.
00510 //   text - a short charact string which will be printed with all messages
00511 //          of this type.
00512 //
00513  _NO_IMPLEMENTATION_;
00514  return 0;
00515 }
00516 //_____________________________________________________________________________
00517 void StLoggerManager::PrintInfo() {
00518    fLogger->info("**************************************************************\n");
00519    fLogger->info("* $Id: StLoggerManager.cxx,v 1.39 2010/04/27 21:31:44 fine Exp $\n");
00520    //  printf("* %s    *\n",m_VersionCVS);
00521    fLogger->info("**************************************************************\n");
00522 }
00523 
00524 //_____________________________________________________________________________
00525 
00526 //_____________________________________________________________________________
00527 //
00528 // Info Messages:
00529 //_____________________________________________________________________________
00530 ostrstream& StLoggerManager::Info(const char* mess, const char* opt,const char *sourceFileName,int lineNumber)
00531 { return Message(mess, "I", opt,sourceFileName,lineNumber);}
00532 //_____________________________________________________________________________
00533 int StLoggerManager::PrintInfos() 
00534 {
00535    _NO_IMPLEMENTATION_;
00536    return 0;
00537    // return PrintList(messCollection[1]); 
00538 }
00539 //_____________________________________________________________________________
00540 const messVec* StLoggerManager::GetInfos() 
00541 {   
00542    _NO_IMPLEMENTATION_;
00543    return 0;
00544    // return (messCollection[1]);
00545 }
00546 //_____________________________________________________________________________
00547 StMessage* StLoggerManager::FindInfo(const char* s1, const char* s2,
00548                                      const char* s3, const char* s4)
00549 {
00550    _NO_IMPLEMENTATION_;
00551    return 0;
00552    // return FindMessage(s1,s2,s3,s4,messCollection[1]);
00553 }
00554 //_____________________________________________________________________________
00555 messVec* StLoggerManager::FindInfoList(const char* s1, const char* s2,
00556                                        const char* s3, const char* s4)
00557 {   
00558    _NO_IMPLEMENTATION_;
00559    return 0;
00560    // return FindMessageList(s1,s2,s3,s4,messCollection[1]);
00561 }
00562 
00563 //_____________________________________________________________________________
00564 //
00565 // Warning Messages:
00566 //_____________________________________________________________________________
00567 ostrstream& StLoggerManager::Warning(const char* mess, const char* opt,const char *sourceFileName,int lineNumber)
00568 { return Message(mess, "W", opt,sourceFileName,lineNumber);}
00569 //_____________________________________________________________________________
00570 int StLoggerManager::PrintWarnings() 
00571 {  
00572    _NO_IMPLEMENTATION_;
00573    return 0;
00574    // return PrintList(messCollection[2]); 
00575 }
00576 //_____________________________________________________________________________
00577 const messVec* StLoggerManager::GetWarnings() 
00578 {
00579    _NO_IMPLEMENTATION_;
00580    return 0;
00581    //   return (messCollection[2]);
00582 }
00583 //_____________________________________________________________________________
00584 StMessage* StLoggerManager::FindWarning(const char* s1, const char* s2,
00585                                         const char* s3, const char* s4)
00586 {
00587    _NO_IMPLEMENTATION_;
00588    return 0;
00589     // return FindMessage(s1,s2,s3,s4,messCollection[2]);
00590 }
00591 //_____________________________________________________________________________
00592 messVec* StLoggerManager::FindWarningList(const char* s1, const char* s2,
00593                                           const char* s3, const char* s4)
00594 {
00595    _NO_IMPLEMENTATION_;
00596    return 0;
00597     // return FindMessageList(s1,s2,s3,s4,messCollection[2]);
00598 }
00599 
00600 //_____________________________________________________________________________
00601 //
00602 // Error Messages:
00603 //_____________________________________________________________________________
00604 ostrstream& StLoggerManager::Error(const char* mess, const char* opt,const char *sourceFileName,int lineNumber)
00605 { return Message(mess, "E", opt,sourceFileName,lineNumber);}
00606 //_____________________________________________________________________________
00607 int StLoggerManager::PrintErrors() 
00608 {
00609    _NO_IMPLEMENTATION_;
00610    return 0;
00611    //return PrintList(messCollection[3]); 
00612 }
00613 //_____________________________________________________________________________
00614 const messVec* StLoggerManager::GetErrors() 
00615 {
00616    _NO_IMPLEMENTATION_;
00617    return 0;
00618  // return (messCollection[3]);
00619 }
00620 //_____________________________________________________________________________
00621 StMessage* StLoggerManager::FindError(const char* s1, const char* s2,
00622                                       const char* s3, const char* s4)
00623 {
00624    _NO_IMPLEMENTATION_;
00625    return 0;
00626     // return FindMessage(s1,s2,s3,s4,messCollection[3]);
00627 }
00628 //_____________________________________________________________________________
00629 messVec* StLoggerManager::FindErrorList(const char* s1, const char* s2,
00630                                         const char* s3, const char* s4)
00631 {  
00632    _NO_IMPLEMENTATION_;
00633    return 0;
00634     // return FindMessageList(s1,s2,s3,s4,messCollection[3]);
00635 }
00636 
00637 //_____________________________________________________________________________
00638 //
00639 // Debug Messages:
00640 //_____________________________________________________________________________
00641 ostrstream& StLoggerManager::Debug(const char* mess, const char* opt,const char *sourceFileName,int lineNumber)
00642 { return Message(mess, "D", opt,sourceFileName,lineNumber);}
00643 //_____________________________________________________________________________
00644 int StLoggerManager::PrintDebug() 
00645 {
00646    _NO_IMPLEMENTATION_;
00647    return 0;
00648    //   return PrintList(messCollection[4]); 
00649 }
00650 //_____________________________________________________________________________
00651 const messVec* StLoggerManager::GetDebugs() 
00652 {
00653 _NO_IMPLEMENTATION_;   return 0;
00654 
00655 //   return (messCollection[4]);
00656 }
00657 //_____________________________________________________________________________
00658 StMessage* StLoggerManager::FindDebug(const char* s1, const char* s2,
00659                                       const char* s3, const char* s4)
00660 {
00661    _NO_IMPLEMENTATION_; return 0;
00662    // return FindMessage(s1,s2,s3,s4,messCollection[4]);
00663 }
00664 //_____________________________________________________________________________
00665 messVec* StLoggerManager::FindDebugList(const char* s1, const char* s2,
00666                                         const char* s3, const char* s4)
00667 {    
00668 _NO_IMPLEMENTATION_;   return 0;
00669     // return FindMessageList(s1,s2,s3,s4,messCollection[4]);
00670 }
00671 
00672 //_____________________________________________________________________________
00673 //
00674 // QAInfo Messages:
00675 //_____________________________________________________________________________
00676 ostrstream& StLoggerManager::QAInfo(const char* mess, const char* opt,const char *sourceFileName,int lineNumber)
00677 { return Message(mess, "Q", opt,sourceFileName,lineNumber);}
00678 //_____________________________________________________________________________
00679 //
00680 // UCMInfo Messages:
00681 //_____________________________________________________________________________
00682 ostrstream& StLoggerManager::UCMInfo(const char* mess, const char* opt,const char *sourceFileName,int lineNumber)
00683 { return Message(mess, "U", opt,sourceFileName,lineNumber);}
00684 //_____________________________________________________________________________
00685 void StLoggerManager::IgnoreRepeats()
00686 { 
00687     AllowRepeats(0);
00688 }
00689 
00690 //_____________________________________________________________________________
00691 void StLoggerManager::AllowRepeats(int nRepeats)
00692 {  
00693    // fAllowRepeat   > 0 the max number to repeat one and the same message
00694    //               == 0 the repating is not allowed
00695    //               == -1 there is no limit;
00696    fAllowRepeat       = nRepeats;
00697    fLastRepeatCounter = 0;
00698    StarOptionFilterPtr& filter = ((StLoggerManager *)mInstance)->GetStarOptionFilter();
00699    if (filter != 0 ) 
00700        filter->setRepeatCounterOption(nRepeats);
00701 
00702 }
00703 
00704 
00705 //_____________________________________________________________________________
00706 void StLoggerManager::AllowRepeats()
00707 { 
00708    AllowRepeats(-1);
00709 }
00710 
00711 
00712 //_____________________________________________________________________________
00713 int StLoggerManager::PrintQAInfo() 
00714 { 
00715 _NO_IMPLEMENTATION_;   return 0;
00716     // return PrintList(messCollection[5]); 
00717 }
00718 //_____________________________________________________________________________
00719 const messVec* StLoggerManager::GetQAInfos() 
00720 {
00721 _NO_IMPLEMENTATION_;   return 0;
00722   // return (messCollection[5]);
00723 }
00724 //_____________________________________________________________________________
00725 StMessage* StLoggerManager::FindQAInfo(const char* s1, const char* s2,
00726                                        const char* s3, const char* s4)
00727 {
00728 _NO_IMPLEMENTATION_;    return 0;
00729     // return FindMessage(s1,s2,s3,s4,messCollection[5]);
00730 }
00731 //_____________________________________________________________________________
00732 messVec* StLoggerManager::FindQAInfoList(const char* s1, const char* s2,
00733                                          const char* s3, const char* s4)
00734 {
00735 _NO_IMPLEMENTATION_;   return 0;
00736    // return FindMessageList(s1,s2,s3,s4,messCollection[5]);
00737 }
00738 
00739 //_____________________________________________________________________________
00740 int StLoggerManager::PrintUCMInfo() 
00741 { 
00742 _NO_IMPLEMENTATION_;   return 0;
00743     // return PrintList(messCollection[5]); 
00744 }
00745 //_____________________________________________________________________________
00746 const messVec* StLoggerManager::GetUCMInfos() 
00747 {
00748 _NO_IMPLEMENTATION_;   return 0;
00749   // return (messCollection[5]);
00750 }
00751 //_____________________________________________________________________________
00752 StMessage* StLoggerManager::FindUCMInfo(const char* s1, const char* s2,
00753                                        const char* s3, const char* s4)
00754 {
00755 _NO_IMPLEMENTATION_;    return 0;
00756     // return FindMessage(s1,s2,s3,s4,messCollection[5]);
00757 }
00758 //_____________________________________________________________________________
00759 messVec* StLoggerManager::FindUCMInfoList(const char* s1, const char* s2,
00760                                          const char* s3, const char* s4)
00761 {
00762 _NO_IMPLEMENTATION_;   return 0;
00763    // return FindMessageList(s1,s2,s3,s4,messCollection[5]);
00764 }
00765 
00766 //_____________________________________________________________________________
00767 ostrstream& StLoggerManager::Fatal(const char* mess, const char* opt,const char *sourceFileName, int lineNumber)
00768 { return Message(mess,"F",opt,sourceFileName,lineNumber);}
00769 
00770 // "As is" Messages:
00771 //_____________________________________________________________________________
00772 ostrstream& StLoggerManager::out(const char* mess)
00773 {return Message(mess,"I","OP-");}
00774 //_____________________________________________________________________________
00775 ostrstream& StLoggerManager::err(const char* mess)
00776 {return Message(mess,"E","EP-");}
00777 
00778 
00779 
00780 // Dummy methods
00781 //_____________________________________________________________________________
00782 int StLoggerManager::PrintAll() 
00783 {  
00784 _NO_IMPLEMENTATION_;   return 0;
00785   //  return PrintList(&messList);        
00786 }
00787 
00788 //_____________________________________________________________________________
00789 const messVec* StLoggerManager::GetAll() 
00790 {
00791 _NO_IMPLEMENTATION_;   return 0;
00792  
00793 //   return (&messList);                 
00794 }
00795 
00796 //_____________________________________________________________________________
00797 int StLoggerManager::RemoveMessage(const char* s1, const char* s2,
00798          const char* s3, const char* s4)
00799 {  return RemoveMessage(FindMessage(s1,s2,s3,s4));             }
00800 
00801 //_____________________________________________________________________________
00802 void StLoggerManager::SetLimit(const char* str, int n)
00803 {  
00804      if (str && str[0] && str[1]) {
00805         LoggerPtr root = Logger::getRootLogger();
00806          AppenderPtr defaultAppender = root->getAppender(_T("defaultAppender"));
00807         if (defaultAppender != 0){
00808            StarOptionFilterPtr filter = new StarOptionFilter();
00809            filter->setRepeatCounterOption(n);
00810            filter->setOption(_T("StringToCount"),str);
00811 //           cout << endl<< "--  Appedner " << defaultAppender->getName() << " -* -* -* -* -* -* -* -* " 
00812 //                 << str << "n = " << n << " -* -* -* -* -* -* -* -* " << endl << endl;               
00813            defaultAppender->addFilter(filter);
00814         }
00815     }
00816   
00817 //   messCounter->SetLimit(str,n);                               
00818 }
00819 //_____________________________________________________________________________
00820 int StLoggerManager::GetLimit(const char* str)
00821 {  
00822 _NO_IMPLEMENTATION_;   return -1;
00823    // return messCounter->GetLimit(str);                          
00824 }
00825 //_____________________________________________________________________________
00826 void StLoggerManager::ListLimits() 
00827 {  
00828 _NO_IMPLEMENTATION_;
00829 // messCounter->ListLimits();                                  
00830 }
00831 //_____________________________________________________________________________
00832 void StLoggerManager::Close()
00833 {
00834  // Close the messenger streams
00835  // Close the QA-related appenders to flush its buffers
00836    if (fgQALogger)  fgQALogger->closeNestedAppenders();
00837    if (fgUCMLogger) fgUCMLogger->closeNestedAppenders();
00838 }
00839 //_____________________________________________________________________________
00840 void StLoggerManager::RemoveLimit(const char* str) 
00841 {  SetLimit(str,-1);                                           }
00842 //_____________________________________________________________________________
00843 void StLoggerManager::SwitchOff(const char* str) 
00844 { SetLimit(str,0);                                             }
00845 //_____________________________________________________________________________
00846 void StLoggerManager::SwitchOn(const char* str) 
00847 {  RemoveLimit(str);                                           }
00848 //_____________________________________________________________________________
00849 void StLoggerManager::FixOn(const char* str) 
00850 {  SetLimit(str,-5);                                           }
00851 //_____________________________________________________________________________
00852 void StLoggerManager::NoLimits() 
00853 {  
00854 _NO_IMPLEMENTATION_;
00855 // messCounter->NoLimits();                                    
00856 }
00857 //_____________________________________________________________________________
00858 void StLoggerManager::MemoryOn() 
00859 {  
00860 _NO_IMPLEMENTATION_;
00861 //   remember=1;                                                 
00862 }
00863 //_____________________________________________________________________________
00864 void StLoggerManager::MemoryOff() 
00865 {
00866 _NO_IMPLEMENTATION_;
00867 // remember=0;                                                 
00868 }
00869 //_____________________________________________________________________________
00870 int StLoggerManager::ListTypes() 
00871 { 
00872 _NO_IMPLEMENTATION_;   return 5;
00873 //   return messTypeList->ListTypes();                           
00874 }
00875 
00876 //_____________________________________________________________________________
00877 void StLoggerManager::SetLevel(Int_t level) 
00878 {
00879    // Map STAR level to the logger level and set the logger level
00880    switch (level) {
00881       case kFatal:
00882          fLogger->setLevel(LOG4CXX_LEVEL_FATAL);
00883          break;
00884       case kError:
00885          fLogger->setLevel(LOG4CXX_LEVEL_ERROR);
00886          break;
00887       case kWarning:
00888          fLogger->setLevel(LOG4CXX_LEVEL_WARN);
00889          break;
00890       case kInfo:
00891          fLogger->setLevel(LOG4CXX_LEVEL_INFO);
00892          break;
00893       case kAll:
00894       case kDebug:
00895       case kDebug2: 
00896          fLogger->setLevel(LOG4CXX_LEVEL_DEBUG);
00897          break;
00898       case kDefault:
00899          // restore the default level (defined the XML configuration if present)
00900          fLogger->setLevel(fDefaultLevel);
00901          break;
00902       default:
00903          fLogger->setLevel(LOG4CXX_LEVEL_DEBUG);
00904          break;            
00905    };   
00906 }
00907 //_____________________________________________________________________________
00908 Int_t StLoggerManager::GetLevel(Int_t) const 
00909 {
00910    // Map the current logger level to the STAR one
00911 #if 0
00912    const LevelPtr &level = fLogger->getLevel();
00913         if (level == &LOG4CXX_LEVEL_DEBUG)  return kDebug; 
00914    else if (level == &LOG4CXX_LEVEL_FATAL)  return kFatal;  
00915    else if (level == &LOG4CXX_LEVEL_ERROR)  return kError;
00916    else if (level == &LOG4CXX_LEVEL_WARN )  return kWarning;
00917    else if (level == &LOG4CXX_LEVEL_INFO )  return kInfo;
00918 #endif
00919    return kAll;
00920 }
00921 
00922 //_____________________________________________________________________________
00923 void StLoggerManager:: DestroyInstance()
00924 {
00925     if (mInstance) {
00926        // There is no method to chech ref. do it blindly.
00927        // fgQALogger->releaseRef(); fgQALogger->releaseRef();
00928        fgUCMLogger->releaseRef();
00929        // fgUCMLogger->releaseRef();
00930        // Logger::getRootLogger()->releaseRef();
00931        // StMessMgr *thisPtr = mInstance;
00932        mInstance = 0; gMessMgr = 0;
00933        // delete thisPtr;
00934     }
00935 }
00936 #if 0
00937 //_____________________________________________________________________________
00938 const char *GetName() 
00939 {
00940   // Returns the name of the current logger
00941   CurrentMessager()
00942 }
00943 #endif
00944    
00945 //_____________________________________________________________________________
00946   // Instantiate the (singleton) class upon loading
00947   //
00948 // static StMessMgr* temp=StLoggerManager::Instance();
00949 // ostrstream& gMess = *(StMessMgr *)StLoggerManager::Instance();
00950 
00951 //_____________________________________________________________________________
00952 // $Id: StLoggerManager.cxx,v 1.39 2010/04/27 21:31:44 fine Exp $
00953 // $Log: StLoggerManager.cxx,v $
00954 // Revision 1.39  2010/04/27 21:31:44  fine
00955 // remove the logger destruction side effect
00956 //
00957 // Revision 1.38  2010/04/23 22:39:11  fine
00958 //  RT #1911. Make interface log4cxx compliant. Remove the dtor dead-lock and add post-mortim clean up
00959 //
00960 // Revision 1.37  2009/09/09 00:05:13  fine
00961 // Merge log4cxx version 9 and 10
00962 //
00963 // Revision 1.36  2009/06/23 19:37:33  fine
00964 // replace QA logger with the dedicated UCM one
00965 //
00966 // Revision 1.35  2009/06/23 19:21:21  fine
00967 // Add the mandatory UCM filters
00968 //
00969 // Revision 1.34  2009/06/22 22:36:01  fine
00970 // Add the new dedicated UCM logger, It should force the recompilation of many STAR packages
00971 //
00972 // Revision 1.33  2009/06/22 01:12:08  fine
00973 // Disable the default UCM. Use log4j.xml instead, for the time being
00974 //
00975 // Revision 1.32  2009/06/19 22:18:36  fine
00976 // pick the technology from the LOGGING var
00977 //
00978 // Revision 1.31  2009/06/17 22:11:59  fine
00979 // Add UCM appender to the StStarLogger and activate it as soon as the env LOGGING is set to UCM
00980 //
00981 // Revision 1.30  2008/05/19 15:08:20  fine
00982 // allow complex formating with several logger stream concurrently. Thanx Victor
00983 //
00984 // Revision 1.29  2008/05/15 23:40:23  fine
00985 // Change the abstarct class return type to separate the different STAR streams
00986 //
00987 // Revision 1.28  2007/08/08 20:50:22  fine
00988 //  Fix bug: some messages submitted via the old interface were lost
00989 //
00990 // Revision 1.27  2007/08/03 21:34:51  fine
00991 // fix StStarLogger for Sl 4.4
00992 //
00993 // Revision 1.26  2007/02/13 22:07:26  perev
00994 // Add the lost part of the ROOT message - location
00995 //
00996 // Revision 1.25  2007/01/30 20:48:57  fine
00997 // Make the deault level for all loggers INFO
00998 //
00999 // Revision 1.24  2007/01/30 19:25:51  fine
01000 // Set the deafult level for QA to b INFO
01001 //
01002 // Revision 1.23  2007/01/25 18:36:38  fine
01003 // Acivate logger level StMaker level run-time adjustment
01004 //
01005 // Revision 1.22  2007/01/23 22:27:14  fine
01006 // Set the dwefault logger level to WARN
01007 //
01008 // Revision 1.21  2006/07/01 01:19:17  fine
01009 // Add new jiob tracking option code
01010 //
01011 // Revision 1.20  2006/06/05 00:21:40  fine
01012 // class the new StMessMgr method to flush the logger buffers
01013 //
01014 // Revision 1.19  2006/05/19 21:42:30  fine
01015 // remove the debug print outs
01016 //
01017 // Revision 1.18  2005/12/20 20:51:15  fine
01018 // fix typo
01019 //
01020 // Revision 1.17  2005/10/10 20:24:17  fine
01021 // Bug fix: add the brackets around the if statements
01022 //
01023 // Revision 1.16  2005/09/14 15:35:25  fine
01024 // Clean up the code
01025 //
01026 // Revision 1.15  2005/08/21 20:20:18  perev
01027 // fix typo in comment
01028 //
01029 // Revision 1.14  2005/08/19 21:01:05  fine
01030 // Manage the ROOT messages with the StarLogger
01031 //
01032 // Revision 1.13  2005/08/05 19:39:14  fine
01033 // Make use of the DOM Configurator instead of PropertyConfigurator
01034 //
01035 // Revision 1.12  2005/03/07 23:17:09  fine
01036 // Fix a bug to allow mnay logger insatnces to print out without any mess
01037 //
01038 // Revision 1.11  2004/11/15 17:25:59  fine
01039 // Make Star filer workign properly
01040 //
01041 // Revision 1.10  2004/11/13 00:28:16  fine
01042 // teach StarOption filter to count the messages
01043 //
01044 // Revision 1.9  2004/11/05 20:24:43  fine
01045 // Remove some redundant lines, clean up
01046 //
01047 // Revision 1.8  2004/11/05 20:24:00  fine
01048 // Replace the obsolete StLoggerManager::Instance with tMessMgr::CurrentMessager()
01049 //
01050 // Revision 1.7  2004/11/03 16:39:32  fine
01051 // add extra method to checl STAR QA info logger
01052 //
01053 // Revision 1.6  2004/11/03 01:33:22  fine
01054 // add the implemantions of the new based methods and clean up
01055 //
01056 // Revision 1.5  2004/09/16 00:13:05  fine
01057 // remove the implict StStarLogger object. We should give log4cxx a chance to complete the intialization
01058 //
01059 // Revision 1.4  2004/05/11 23:48:19  fine
01060 // update the default logger pattern
01061 //
01062 // Revision 1.3  2004/05/11 23:21:58  fine
01063 // add the default logger description
01064 //
01065 // Revision 1.2  2004/05/11 22:42:27  fine
01066 // Add the default configurator
01067 //
01068 // Revision 1.1  2004/05/11 20:58:48  fine
01069 // first implemantation of the abstarct STAR messeger via log4cxx package
01070 //