STEER/STEERBase/AliLog.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 ///////////////////////////////////////////////////////////////////////////////
  19 //                                                                           //
  20 // class for logging debug, info and error messages                          //
  21 //                                                                           //
  22 // The AliLog class is a singleton class. It allows to steer the output      //
  23 // level and output streams for different types of messages via static       //
  24 // methods.                                                                  //
  25 //                                                                           //
  26 // It also handles the messages produces by the preprocessor macros defined  //
  27 // in the header file: AliDebug, AliInfo, AliWarning, AliError, AliFatal.    //
  28 //                                                                           //
  29 // More details about the message logging can be found on the ALICE Offline  //
  30 // web page.                                                                 //
  31 //                                                                           //
  32 ///////////////////////////////////////////////////////////////////////////////
  33
  34 #include <cstdlib>
  35 #include <strings.h>
  36 #include <Riostream.h>
  37 #include <TError.h>
  38 #include <TNamed.h>
  39 #include <TSystem.h>
  40 #include <TEnv.h>
  41 #include <TArrayC.h>
  42 #include <Varargs.h> // platform independent definition of va_copy
  43
  44 #include "AliLog.h"
  45
  46 using std::endl;
  47 using std::cout;
  48 using std::ostream;
  49 using std::cerr;
  50 using std::ofstream;
  51 using std::ios;
  52 ClassImp(AliLog)
  53
  54 // implementation of a singleton here
  55 AliLog* AliLog::fgInstance = NULL;
  56
  57 Bool_t AliLog::fgDebugEnabled = kTRUE;
  58 Bool_t AliLog::fgCoreEnabled = kFALSE;
  59
  60 /**
  61  * get root logger singleton instance
  62  */
  63 AliLog *AliLog::GetRootLogger()
  64 {
  65         if (fgInstance == NULL)
  66         {
  67                 // creating singleton
  68                 fgInstance =  new AliLog;
  69         }
  70
  71         return fgInstance;
  72 }
  73
  74 /**
  75  * delete the root logger singleton instance
  76  */
  77 void AliLog::DeleteRootLogger()
  78 {
  79         if (fgInstance != NULL)
  80         {
  81                 delete fgInstance;
  82                 fgInstance = NULL;
  83         }
  84 }
  85
  86 /**
  87  * default private constructor
  88  */
  89 AliLog::AliLog() :
  90   TObject(),
  91   fGlobalLogLevel(kInfo),
  92   fModuleDebugLevels(),
  93   fClassDebugLevels(),
  94   fPrintRepetitions(kTRUE),
  95   fRepetitions(0),
  96   fLastType(0),
  97   fLastMessage(),
  98   fLastModule(),
  99   fLastClassName(),
 100   fLastFunction(),
 101   fLastFile(),
 102   fLastLine(0)
 103 {
 104 // default constructor: set default values
 105
 106   for (Int_t iType = kFatal; iType < kMaxType; iType++)
 107   {
 108     fOutputTypes[iType] = 0;
 109     fFileNames[iType] = "";
 110     fOutputFiles[iType] = NULL;
 111     fOutputStreams[iType] = NULL;
 112     fCallBacks[iType]=NULL;
 113
 114     fPrintType[iType] = kTRUE;
 115     fPrintModule[iType] = kFALSE;
 116     fPrintScope[iType] = kTRUE;
 117     fPrintLocation[iType] = (iType == kDebug);
 118   }
 119
 120   // TO BE REVIEWED
 121   // replace the previous instance by this one
 122   if (fgInstance) delete fgInstance;
 123   fgInstance = this;
 124
 125   SetHandleRootMessages(kTRUE);
 126
 127   // read the .rootrc settings
 128   ReadEnvSettings();
 129 }
 130
 131 /**
 132  * private destructor
 133  */
 134 AliLog::~AliLog()
 135 {
 136 // destructor: clean up and reset instance pointer
 137
 138   if (fRepetitions > 0) PrintRepetitions();
 139
 140   for (Int_t i = 0; i < fModuleDebugLevels.GetEntriesFast(); i++)
 141   {
 142     if (fModuleDebugLevels[i]) fModuleDebugLevels[i]->Delete();
 143   }
 144
 145   fClassDebugLevels.Delete();
 146
 147   for (Int_t i = 0; i < fClassDebugLevels.GetEntriesFast(); i++)
 148   {
 149     if (fClassDebugLevels[i]) fClassDebugLevels[i]->Delete();
 150   }
 151
 152   fClassDebugLevels.Delete();
 153
 154   for (Int_t iType = kFatal; iType < kMaxType; iType++)
 155   {
 156     CloseFile(iType);
 157   }
 158
 159   fflush(stderr);
 160   fflush(stdout);
 161
 162   fgInstance = NULL;
 163 }
 164
 165 // NOT IMPLEMENTED!?
 166 //_____________________________________________________________________________
 167 AliLog::AliLog(const AliLog& log) :
 168   TObject(log),
 169   fGlobalLogLevel(log.fGlobalLogLevel),
 170   fModuleDebugLevels(log.fModuleDebugLevels),
 171   fClassDebugLevels(log.fClassDebugLevels),
 172   fPrintRepetitions(log.fPrintRepetitions),
 173   fRepetitions(log.fRepetitions),
 174   fLastType(log.fLastType),
 175   fLastMessage(log.fLastMessage),
 176   fLastModule(log.fLastModule),
 177   fLastClassName(log.fLastClassName),
 178   fLastFunction(log.fLastFunction),
 179   fLastFile(log.fLastFile),
 180   fLastLine(log.fLastLine)
 181 {
 182 // copy constructor
 183
 184   Fatal("AliLog", "copy constructor not implemented");
 185 }
 186
 187 // NOT IMPLEMENTED!?
 188 //_____________________________________________________________________________
 189 AliLog& AliLog::operator = (const AliLog& /*log*/)
 190 {
 191 // assignment operator
 192
 193   Fatal("operator =", "assignment operator not implemented");
 194   return *this;
 195 }
 196
 197
 198 /**
 199  * gSystem see TSystem.h
 200  * gEnv see TEnv.h
 201  *
 202  * LOG_NO_DEBUG: fgDebugEnabled <- false
 203  * AliRoot.AliLog.EnableDebug
 204  * AliRoot.AliLog.GlobalLogLevel
 205  */
 206 //_____________________________________________________________________________
 207 void AliLog::ReadEnvSettings()
 208 {
 209 // load settings from the root configuration file (.rootrc)
 210 // and from environment variables
 211
 212   static const char* typeNames[kMaxType] = {"kFatal", "kError", "kWarning", "kInfo", "kDebug"};
 213
 214   // debug en- or disabling
 215   if (gSystem->Getenv("LOG_NO_DEBUG"))
 216   {
 217     fgDebugEnabled = kFALSE;
 218   }
 219   else if (gEnv->Defined("AliRoot.AliLog.EnableDebug"))
 220   {
 221     fgDebugEnabled = gEnv->GetValue("AliRoot.AliLog.EnableDebug", fgDebugEnabled);
 222     AliInfo(Form("debug %sabled", ((fgDebugEnabled) ? "en" : "dis")));
 223   }
 224
 225   // global log level
 226   if (gEnv->Defined("AliRoot.AliLog.GlobalLogLevel"))
 227   {
 228     const char* type = gEnv->GetValue("AliRoot.AliLog.GlobalLogLevel", "");
 229
 230     for (Int_t iType = kFatal; iType < kMaxType; iType++)
 231     {
 232       if (strcmp(type, typeNames[iType]) == 0) fGlobalLogLevel = iType;
 233     }
 234
 235     AliDebug(3, Form("global log level set to %d", fGlobalLogLevel));
 236   }
 237
 238   // global debug level
 239   if (gEnv->Defined("AliRoot.AliLog.GlobalDebugLevel"))
 240   {
 241     Int_t level = gEnv->GetValue("AliRoot.AliLog.GlobalDebugLevel", Int_t(fGlobalLogLevel - kDebugOffset));
 242     if (level < -kDebugOffset) level = kDebugOffset;
 243     fGlobalLogLevel = kDebugOffset + level;
 244     AliDebug(3, Form("global debug level set to %d", fGlobalLogLevel - kDebugOffset));
 245   }
 246
 247   // module debug level
 248   if (gEnv->Defined("AliRoot.AliLog.ModuleDebugLevel"))
 249   {
 250     TString levels = gEnv->GetValue("AliRoot.AliLog.ModuleDebugLevel", "");
 251     char* p = const_cast<char*>(levels.Data());
 252
 253     while (const char* module = strtok(p, " "))
 254     {
 255       p = NULL;
 256       char* pos = const_cast<char*>(index(module, ':'));
 257       if (!pos) continue;
 258       *(pos++) = '\0';
 259       Int_t level = atoi(pos);
 260       SetModuleDebugLevel(module, level);
 261       AliDebug(3, Form("debug level for module %s set to %d", module, level));
 262     }
 263   }
 264
 265   // class debug level
 266   if (gEnv->Defined("AliRoot.AliLog.ClassDebugLevel"))
 267   {
 268     TString levels = gEnv->GetValue("AliRoot.AliLog.ClassDebugLevel", "");
 269     char* p = const_cast<char*>(levels.Data());
 270
 271     while (const char* className = strtok(p, " "))
 272     {
 273       p = NULL;
 274       char* pos = const_cast<char*>(index(className, ':'));
 275       if (!pos) continue;
 276       *(pos++) = '\0';
 277       Int_t level = atoi(pos);
 278       SetClassDebugLevel(className, level);
 279       AliDebug(3, Form("debug level for class %s set to %d", className, level));
 280     }
 281   }
 282
 283   // general output stream
 284   if (gEnv->Defined("AliRoot.AliLog.Output"))
 285   {
 286     TString stream = gEnv->GetValue("AliRoot.AliLog.Output", "Standard");
 287
 288     if (stream.CompareTo("standard", TString::kIgnoreCase) == 0)
 289     {
 290       SetStandardOutput();
 291       AliDebug(3, "output stream set to standard output for all types");
 292     }
 293     else if (stream.CompareTo("error", TString::kIgnoreCase) == 0)
 294     {
 295       SetErrorOutput();
 296       AliDebug(3, "output stream set to error output for all types");
 297     }
 298     else if (!stream.IsNull())
 299     {
 300       SetFileOutput(stream);
 301       AliDebug(3, Form("output stream set to file %s for all types", stream.Data()));
 302     }
 303   }
 304
 305   // individual output streams
 306   for (Int_t iType = kFatal; iType < kMaxType; iType++)
 307   {
 308     TString name("AliRoot.AliLog.Output.");
 309     name += &typeNames[iType][1];
 310
 311     if (gEnv->Defined(name))
 312     {
 313       TString stream = gEnv->GetValue(name, "Standard");
 314
 315       if (stream.CompareTo("standard", TString::kIgnoreCase) == 0)
 316       {
 317         SetStandardOutput(EType_t(iType));
 318         AliDebug(3, Form("output stream set to standard output for type %s", typeNames[iType]));
 319       }
 320       else if (stream.CompareTo("error", TString::kIgnoreCase) == 0)
 321       {
 322         SetErrorOutput(EType_t(iType));
 323         AliDebug(3, Form("output stream set to error output for type %s", typeNames[iType]));
 324       }
 325       else if (!stream.IsNull())
 326       {
 327         SetFileOutput(EType_t(iType), stream);
 328         AliDebug(3, Form("output stream set to file %s for type %s", stream.Data(), typeNames[iType]));
 329       }
 330     }
 331   }
 332
 333   // handling of root error messages
 334   if (gEnv->Defined("AliRoot.AliLog.HandleRootMessages"))
 335   {
 336     Bool_t on = gEnv->GetValue("AliRoot.AliLog.HandleRootMessages", kTRUE);
 337     SetHandleRootMessages(on);
 338     AliDebug(3, Form("handling of root messages %sabled", ((on) ? "en" : "dis")));
 339   }
 340
 341   // printout settings
 342   static const char* settingNames[4] = {"Type", "Module", "Scope", "Location"};
 343   Bool_t* settings[] = {fPrintType, fPrintModule, fPrintScope, fPrintLocation};
 344
 345   for (Int_t iSetting = 0; iSetting < 4; iSetting++)
 346   {
 347     TString name("AliRoot.AliLog.Print");
 348     name += settingNames[iSetting];
 349
 350     if (gEnv->Defined(name))
 351     {
 352       Bool_t on = gEnv->GetValue(name, settings[iSetting][0]);
 353
 354       for (Int_t iType = kFatal; iType < kMaxType; iType++)
 355       {
 356         settings[iSetting][iType] = on;
 357       }
 358       AliDebug(3, Form("printing of %s %sabled for all types", settingNames[iSetting], ((on) ? "en" : "dis")));
 359     }
 360
 361     for (Int_t iType = kFatal; iType < kMaxType; iType++)
 362     {
 363       TString nameType = name + "." + &typeNames[iType][1];
 364
 365       if (gEnv->Defined(nameType))
 366       {
 367         Bool_t on = gEnv->GetValue(nameType, settings[iSetting][iType]);
 368         settings[iSetting][iType] = on;
 369         AliDebug(3, Form("printing of %s %sabled for type %s", settingNames[iSetting], ((on) ? "en" : "dis"), typeNames[iType]));
 370       }
 371     }
 372   }
 373
 374   // repetition of messages
 375   if (gEnv->Defined("AliRoot.AliLog.PrintRepetitions"))
 376   {
 377     Bool_t on = gEnv->GetValue("AliRoot.AliLog.PrintRepetitions", kTRUE);
 378     fPrintRepetitions = on;
 379     AliDebug(3, Form("printing of message repetitions %sabled", ((on) ? "en" : "dis")));
 380   }
 381   if (gSystem->Getenv("ALIROOT_FORCE_COREDUMP")){
 382     EnableCoreDump(kTRUE);
 383   }
 384
 385 }
 386
 387
 388 //_____________________________________________________________________________
 389 void AliLog::RootErrorHandler(Int_t level, Bool_t abort,
 390                               const char* location, const char* message)
 391 {
 392 // new error handler for messages from root
 393
 394   switch (level)
 395   {
 396   case ::kFatal    : level = kFatal; break;
 397   case ::kSysError :
 398     DefaultErrorHandler(level, abort, location, message);
 399     return;
 400   case ::kBreak    :
 401     DefaultErrorHandler(level, abort, location, message);
 402     return;
 403   case ::kError    : level = kError; break;
 404   case ::kWarning  : level = kWarning; break;
 405   case ::kInfo     : level = kInfo; break;
 406   default          : level = kDebug; break;
 407   }
 408   AliLog::Message(level, message, "ROOT", NULL, location, NULL, 0);
 409 }
 410
 411
 412 // DEPRECATED: USE A CONFIGURATION FILE INSTEAD
 413 //_____________________________________________________________________________
 414 void AliLog::EnableDebug(Bool_t enabled)
 415 {
 416 // enable or disable debug output
 417
 418   fgDebugEnabled = enabled;
 419 }
 420
 421 void AliLog::EnableCoreDump(Bool_t enabled)
 422 {
 423 // enable or disable debug output
 424
 425   fgCoreEnabled = enabled;
 426   gSystem->ResetSignal(kSigFloatingException,enabled);
 427   gSystem->ResetSignal(kSigSegmentationViolation,enabled);
 428
 429
 430 }
 431
 432
 433
 434 //_____________________________________________________________________________
 435 void AliLog::SetGlobalLogLevel(EType_t type)
 436 {
 437 // set the global debug level
 438
 439   // TO BE DELETED
 440   if (!fgInstance) new AliLog;
 441   fgInstance->fGlobalLogLevel = type;
 442 }
 443
 444 //_____________________________________________________________________________
 445 Int_t AliLog::GetGlobalLogLevel()
 446 {
 447 // get the global debug level
 448
 449   if (!fgInstance) new AliLog;
 450   return fgInstance->fGlobalLogLevel;
 451 }
 452
 453 //_____________________________________________________________________________
 454 void AliLog::SetGlobalDebugLevel(Int_t level)
 455 {
 456 // set the global debug level
 457
 458   if (!fgInstance) new AliLog;
 459   if (level < -kDebugOffset) level = -kDebugOffset;
 460   fgInstance->fGlobalLogLevel = kDebugOffset + level;
 461 }
 462
 463 //_____________________________________________________________________________
 464 Int_t AliLog::GetGlobalDebugLevel()
 465 {
 466 // get the global debug level
 467
 468   if (!fgInstance) new AliLog;
 469   return fgInstance->fGlobalLogLevel - kDebugOffset;
 470 }
 471
 472 //_____________________________________________________________________________
 473 void AliLog::SetModuleDebugLevel(const char* module, Int_t level)
 474 {
 475 // set the debug level for the given module
 476
 477   if (!module) return;
 478   if (!fgInstance) new AliLog;
 479   TObject* obj = fgInstance->fModuleDebugLevels.FindObject(module);
 480   if (!obj) {
 481     obj = new TNamed(module, module);
 482     fgInstance->fModuleDebugLevels.Add(obj);
 483   }
 484   level += kDebugOffset;
 485   if (level < kFatal) level = kFatal;
 486   obj->SetUniqueID(level);
 487 }
 488
 489 //_____________________________________________________________________________
 490 void AliLog::ClearModuleDebugLevel(const char* module)
 491 {
 492 // remove the setting of the debug level for the given module
 493
 494   if (!module) return;
 495   if (!fgInstance) new AliLog;
 496   TObject* obj = fgInstance->fModuleDebugLevels.FindObject(module);
 497   if (obj) delete fgInstance->fModuleDebugLevels.Remove(obj);
 498 }
 499
 500 //_____________________________________________________________________________
 501 void AliLog::SetClassDebugLevel(const char* className, Int_t level)
 502 {
 503 // set the debug level for the given class
 504
 505   if (!className) return;
 506   if (!fgInstance) new AliLog;
 507   TObject* obj = fgInstance->fClassDebugLevels.FindObject(className);
 508   if (!obj) {
 509     obj = new TNamed(className, className);
 510     fgInstance->fClassDebugLevels.Add(obj);
 511   }
 512   level += kDebugOffset;
 513   if (level < kFatal) level = kFatal;
 514   obj->SetUniqueID(level);
 515 }
 516
 517 //_____________________________________________________________________________
 518 void AliLog::ClearClassDebugLevel(const char* className)
 519 {
 520 // remove the setting of the debug level for the given class
 521
 522   if (!className) return;
 523   if (!fgInstance) new AliLog;
 524   TObject* obj = fgInstance->fClassDebugLevels.FindObject(className);
 525   if (obj) delete fgInstance->fClassDebugLevels.Remove(obj);
 526 }
 527
 528
 529 //_____________________________________________________________________________
 530 void AliLog::SetStandardOutput()
 531 {
 532 // write all log messages to the standard output (stdout)
 533
 534   if (!fgInstance) new AliLog;
 535   for (Int_t iType = kFatal; iType < kMaxType; iType++) {
 536     fgInstance->CloseFile(iType);
 537     fgInstance->fOutputTypes[iType] = 0;
 538   }
 539 }
 540
 541 //_____________________________________________________________________________
 542 void AliLog::SetStandardOutput(EType_t type)
 543 {
 544 // write log messages of the given type to the standard output (stdout)
 545
 546   if ((type < kFatal) || (type >= kMaxType)) return;
 547   if (!fgInstance) new AliLog;
 548   fgInstance->CloseFile(type);
 549   fgInstance->fOutputTypes[type] = 0;
 550 }
 551
 552 //_____________________________________________________________________________
 553 void AliLog::SetErrorOutput()
 554 {
 555 // write all log messages to the error output (stderr)
 556
 557   if (!fgInstance) new AliLog;
 558   for (Int_t iType = kFatal; iType < kMaxType; iType++) {
 559     fgInstance->CloseFile(iType);
 560     fgInstance->fOutputTypes[iType] = 1;
 561   }
 562 }
 563
 564 //_____________________________________________________________________________
 565 void AliLog::SetErrorOutput(EType_t type)
 566 {
 567 // write log messages of the given type to the error output (stderr)
 568
 569   if ((type < kFatal) || (type >= kMaxType)) return;
 570   if (!fgInstance) new AliLog;
 571   fgInstance->CloseFile(type);
 572   fgInstance->fOutputTypes[type] = 1;
 573 }
 574
 575 //_____________________________________________________________________________
 576 void AliLog::SetFileOutput(const char* fileName)
 577 {
 578 // write all log messages to the given file
 579
 580   if (!fgInstance) new AliLog;
 581   for (Int_t iType = kFatal; iType < kMaxType; iType++) {
 582     if ((fgInstance->fOutputTypes[iType] == 2) &&
 583         (fgInstance->fFileNames[iType].CompareTo(fileName) != 0)) {
 584       fgInstance->CloseFile(iType);
 585     }
 586     fgInstance->fOutputTypes[iType] = 2;
 587     fgInstance->fFileNames[iType] = fileName;
 588     fgInstance->fOutputFiles[iType] = NULL;
 589     fgInstance->fOutputStreams[iType] = NULL;
 590   }
 591 }
 592
 593 //_____________________________________________________________________________
 594 void AliLog::SetFileOutput(EType_t type, const char* fileName)
 595 {
 596 // write log messages of the given type to the given file
 597
 598   if ((type < kFatal) || (type >= kMaxType)) return;
 599   if (!fgInstance) new AliLog;
 600   if ((fgInstance->fOutputTypes[type] == 2) &&
 601       (fgInstance->fFileNames[type].CompareTo(fileName) != 0)) {
 602     fgInstance->CloseFile(type);
 603   }
 604   fgInstance->fOutputTypes[type] = 2;
 605   fgInstance->fFileNames[type] = fileName;
 606   fgInstance->fOutputFiles[type] = NULL;
 607   fgInstance->fOutputStreams[type] = NULL;
 608 }
 609
 610 //_____________________________________________________________________________
 611 void AliLog::CloseFile(Int_t type)
 612 {
 613 // close the file for the given type if needed
 614
 615   if ((fOutputTypes[type] == 2) && fOutputFiles[type]) {
 616     Bool_t closeFile = kTRUE;
 617     for (Int_t iType = kFatal; iType < kMaxType; iType++) {
 618       if ((iType != type) && (fOutputFiles[iType] == fOutputFiles[type])) {
 619         closeFile = kFALSE;
 620       }
 621     }
 622     if (closeFile) {
 623       fclose(fOutputFiles[type]);
 624       ofstream* stream=reinterpret_cast<ofstream*>(fOutputStreams[type]);
 625       stream->close();
 626       delete fOutputStreams[type];
 627     }
 628   }
 629   fOutputFiles[type] = NULL;
 630   fOutputStreams[type] = NULL;
 631   fFileNames[type] = "";
 632   fOutputTypes[type] = 0;
 633 }
 634
 635 //_____________________________________________________________________________
 636 FILE* AliLog::GetOutputStream(Int_t type)
 637 {
 638 // get the output stream for the given type of messages
 639
 640   if (type > kDebug) type = kDebug;
 641   if (fOutputTypes[type] == 0) return stdout;
 642   else if (fOutputTypes[type] == 1) return stderr;
 643   else if (fOutputTypes[type] == 2) {
 644     if (!fOutputFiles[type]) {
 645       FILE* file = NULL;
 646       ostream* stream = NULL;
 647       if (!fFileNames[type].IsNull()) {
 648         for (Int_t iType = kFatal; iType < kMaxType; iType++) {
 649           if ((iType != type) &&
 650               (fFileNames[iType].CompareTo(fFileNames[type]) == 0) &&
 651               fOutputFiles[iType]) {
 652             file = fOutputFiles[iType];
 653             stream = fOutputStreams[iType];
 654             break;
 655           }
 656         }
 657         if (!file) {
 658           file = fopen(fFileNames[type], "a");
 659           stream = new ofstream(fFileNames[type], ios::app);
 660         }
 661       }
 662       fOutputFiles[type] = file;
 663       fOutputStreams[type] = stream;
 664       if (!file) CloseFile(type);
 665     }
 666     if (fOutputFiles[type]) return fOutputFiles[type];
 667   }
 668
 669   return stdout;
 670 }
 671
 672 //_____________________________________________________________________________
 673 void AliLog::Flush()
 674 {
 675 // flush the output streams
 676
 677   if (!fgInstance) new AliLog;
 678   for (Int_t iType = kFatal; iType < kMaxType; iType++) {
 679     if (fgInstance->fOutputFiles[iType]) {
 680       fflush(fgInstance->fOutputFiles[iType]);
 681       fgInstance->fOutputStreams[iType]->flush();
 682     }
 683   }
 684   fflush(stderr);
 685   fflush(stdout);
 686 }
 687
 688
 689 //_____________________________________________________________________________
 690 void AliLog::SetHandleRootMessages(Bool_t on)
 691 {
 692 // enable or disable the handling of messages form root
 693
 694   if (!fgInstance) new AliLog;
 695   if (on) {
 696     SetErrorHandler(RootErrorHandler);
 697   } else {
 698     SetErrorHandler(DefaultErrorHandler);
 699   }
 700 }
 701
 702
 703 //_____________________________________________________________________________
 704 void AliLog::SetPrintType(Bool_t on)
 705 {
 706 // switch on or off the printing of the message type for all message types
 707
 708   if (!fgInstance) new AliLog;
 709   for (Int_t iType = kFatal; iType < kMaxType; iType++) {
 710     fgInstance->fPrintType[iType] = on;
 711   }
 712 }
 713
 714 //_____________________________________________________________________________
 715 void AliLog::SetPrintType(EType_t type, Bool_t on)
 716 {
 717 // switch on or off the printing of the message type for the given message type
 718
 719   if ((type < kFatal) || (type >= kMaxType)) return;
 720   if (!fgInstance) new AliLog;
 721   fgInstance->fPrintType[type] = on;
 722 }
 723
 724 //_____________________________________________________________________________
 725 void AliLog::SetPrintModule(Bool_t on)
 726 {
 727 // switch on or off the printing of the module for all message types
 728
 729   if (!fgInstance) new AliLog;
 730   for (Int_t iType = kFatal; iType < kMaxType; iType++) {
 731     fgInstance->fPrintModule[iType] = on;
 732   }
 733 }
 734
 735 //_____________________________________________________________________________
 736 void AliLog::SetPrintModule(EType_t type, Bool_t on)
 737 {
 738 // switch on or off the printing of the module for the given message type
 739
 740   if ((type < kFatal) || (type >= kMaxType)) return;
 741   if (!fgInstance) new AliLog;
 742   fgInstance->fPrintModule[type] = on;
 743 }
 744
 745 //_____________________________________________________________________________
 746 void AliLog::SetPrintScope(Bool_t on)
 747 {
 748 // switch on or off the printing of the scope/class name for all message types
 749
 750   if (!fgInstance) new AliLog;
 751   for (Int_t iType = kFatal; iType < kMaxType; iType++) {
 752     fgInstance->fPrintScope[iType] = on;
 753   }
 754 }
 755
 756 //_____________________________________________________________________________
 757 void AliLog::SetPrintScope(EType_t type, Bool_t on)
 758 {
 759 // switch on or off the printing of the scope/class name
 760 // for the given message type
 761
 762   if ((type < kFatal) || (type >= kMaxType)) return;
 763   if (!fgInstance) new AliLog;
 764   fgInstance->fPrintScope[type] = on;
 765 }
 766
 767 //_____________________________________________________________________________
 768 void AliLog::SetPrintLocation(Bool_t on)
 769 {
 770 // switch on or off the printing of the file name and line number
 771 // for all message types
 772
 773   if (!fgInstance) new AliLog;
 774   for (Int_t iType = kFatal; iType < kMaxType; iType++) {
 775     fgInstance->fPrintLocation[iType] = on;
 776   }
 777 }
 778
 779 //_____________________________________________________________________________
 780 void AliLog::SetPrintLocation(EType_t type, Bool_t on)
 781 {
 782 // switch on or off the printing of the file name and line number
 783 // for the given message type
 784
 785   if ((type < kFatal) || (type >= kMaxType)) return;
 786   if (!fgInstance) new AliLog;
 787   fgInstance->fPrintLocation[type] = on;
 788 }
 789
 790
 791 //_____________________________________________________________________________
 792 void AliLog::SetPrintRepetitions(Bool_t on)
 793 {
 794 // switch on or off the printing of the number of repetitions of a message
 795 // instead of repeating the same message
 796
 797   if (!fgInstance) new AliLog;
 798   if (!on && (fgInstance->fRepetitions > 0)) fgInstance->PrintRepetitions();
 799   fgInstance->fPrintRepetitions = on;
 800 }
 801
 802
 803 //_____________________________________________________________________________
 804 void AliLog::WriteToFile(const char* name, Int_t option)
 805 {
 806 // write the log object with the given name and option to the current file
 807
 808   if (!fgInstance) new AliLog;
 809   fgInstance->TObject::Write(name, option);
 810 }
 811
 812
 813 //_____________________________________________________________________________
 814 UInt_t AliLog::GetLogLevel(const char* module, const char* className) const
 815 {
 816 // get the logging level for the given module and class
 817
 818   if (!fgInstance) new AliLog;
 819   if (className) {
 820     TObject* obj = fgInstance->fClassDebugLevels.FindObject(className);
 821     if (obj) return obj->GetUniqueID();
 822   }
 823   if (module) {
 824     TObject* obj = fgInstance->fModuleDebugLevels.FindObject(module);
 825     if (obj) return obj->GetUniqueID();
 826   }
 827   return fgInstance->fGlobalLogLevel;
 828 }
 829
 830 //_____________________________________________________________________________
 831 Int_t AliLog::GetDebugLevel(const char* module, const char* className)
 832 {
 833 // get the debug level for the given module and class
 834
 835   if (!fgInstance) new AliLog;
 836   return fgInstance->GetLogLevel(module, className) - kDebugOffset;
 837 }
 838
 839 //_____________________________________________________________________________
 840 void AliLog::PrintMessage(UInt_t type, const char* message,
 841                           const char* module, const char* className,
 842                           const char* function, const char* file, Int_t line)
 843 {
 844 // print the given message
 845
 846   // don't print the message if it is repeated
 847   if (fPrintRepetitions &&
 848       (fLastType == type) &&
 849       (message && (fLastMessage.CompareTo(message) == 0)) &&
 850       ((module && (fLastModule.CompareTo(module) == 0)) ||
 851        (!module && fLastModule.IsNull())) &&
 852       ((className && (fLastClassName.CompareTo(className) == 0)) ||
 853        (!className && fLastClassName.IsNull())) &&
 854       ((function && (fLastFunction.CompareTo(function) == 0)) ||
 855        (!function && fLastFunction.IsNull()))&&
 856       ((file && (fLastFile.CompareTo(file) == 0)) ||
 857        (!file && fLastFile.IsNull())) &&
 858       (fLastLine == line)) {
 859     fRepetitions++;
 860     return;
 861   }
 862
 863   // print number of repetitions
 864   if (fRepetitions > 0) PrintRepetitions();
 865
 866   // remember this message
 867   fRepetitions = 0;
 868   fLastType = type;
 869   fLastMessage = message;
 870   fLastModule = module;
 871   fLastClassName = className;
 872   fLastFunction = function;
 873   fLastFile = file;
 874   fLastLine = line;
 875
 876   // print the message
 877   FILE* stream = GetOutputStream(type);
 878   static const char* typeNames[kMaxType] =
 879     {"Fatal", "Error", "Warning", "Info", "Debug"};
 880
 881   if (fPrintType[type]) {
 882     PrintString(type, stream, "%c-", typeNames[type][0]);
 883   }
 884   if (fPrintModule[type] && module) {
 885     PrintString(type, stream, "%s/", module);
 886   }
 887   if (fPrintScope[type] && className) {
 888     PrintString(type, stream, "%s::", className);
 889   }
 890   if (message) {
 891     PrintString(type, stream, "%s: %s", function, message);
 892   } else {
 893     PrintString(type, stream, "%s", function);
 894   }
 895   if (fPrintLocation[type] && file) {
 896     PrintString(type, stream, " (%s:%.0d)", file, line);
 897   }
 898   if (message) {
 899     PrintString(type, stream, "\n");
 900   } else {
 901     PrintString(type, stream, ": ");
 902   }
 903   if (fCallBacks[type]) (*(fCallBacks[type]))((EType_t)type, NULL);
 904 }
 905
 906 //_____________________________________________________________________________
 907 void AliLog::PrintRepetitions()
 908 {
 909 // print number of repetitions
 910
 911   PrintString(fLastType, GetOutputStream(fLastType), " <message repeated %d time%s>\n",
 912           fRepetitions, (fRepetitions > 1) ? "s" : "");
 913   if (fCallBacks[fLastType]) (*(fCallBacks[fLastType]))((EType_t)fLastType, NULL);
 914 }
 915
 916 //_____________________________________________________________________________
 917 void AliLog::Message(UInt_t level, const char* message,
 918                      const char* module, const char* className,
 919                      const char* function, const char* file, Int_t line)
 920 {
 921 // print a log message
 922
 923   if (!fgInstance) new AliLog;
 924
 925   // get the message type
 926   UInt_t type = level;
 927   if (type >= kMaxType) type = kMaxType - 1;
 928
 929   // print the message if the debug level allows
 930   if (level <= fgInstance->GetLogLevel(module, className)) {
 931     fgInstance->PrintMessage(type, message,
 932                              module, className, function, file, line);
 933   }
 934
 935   // abort in case of a fatal message
 936   if (type == kFatal) {
 937     delete fgInstance;
 938     if (gSystem) {
 939       gSystem->StackTrace();
 940       if (fgCoreEnabled) MakeCoreDump("core.AliRoot");
 941       gSystem->Abort();
 942     } else {
 943       if (fgCoreEnabled) MakeCoreDump("core.AliRoot");
 944       ::abort();
 945     }
 946   }
 947 }
 948
 949
 950
 951 //_____________________________________________________________________________
 952 void AliLog::Debug(UInt_t level, const char* message,
 953                    const char* module, const char* className,
 954                    const char* function, const char* file, Int_t line)
 955 {
 956 // print a debug message
 957
 958   if (level == 0) level = 1;
 959   level += kDebugOffset;
 960   Message(level, message, module, className, function, file, line);
 961 }
 962
 963
 964 //_____________________________________________________________________________
 965 Int_t AliLog::RedirectStdoutTo(EType_t type, UInt_t level, const char* module,
 966                                const char* className, const char* function,
 967                                const char* file, Int_t line, Bool_t print)
 968 {
 969 // redirect the standard output to the stream of the given type
 970
 971   if (!fgInstance) new AliLog;
 972   return fgInstance->RedirectTo(stdout, type, level, module, className,
 973                                 function, file, line, print);
 974 }
 975
 976 //_____________________________________________________________________________
 977 Int_t AliLog::RedirectStderrTo(EType_t type, UInt_t level, const char* module,
 978                                const char* className, const char* function,
 979                                const char* file, Int_t line, Bool_t print)
 980 {
 981 // redirect the standard error output to the stream of the given type
 982
 983   if (!fgInstance) new AliLog;
 984   return fgInstance->RedirectTo(stderr, type, level, module, className,
 985                                 function, file, line, print);
 986 }
 987
 988 //_____________________________________________________________________________
 989 Int_t AliLog::RedirectTo(FILE* stream, EType_t type, UInt_t level,
 990                          const char* module, const char* className,
 991                          const char* function, const char* file, Int_t line,
 992                          Bool_t print)
 993 {
 994 // redirect the standard (error) output stream to the stream of the given type
 995
 996   // get the original file descriptor to be able to restore it later
 997   Int_t original = dup(fileno(stream));
 998   fflush(stream);
 999
1000   // flush the stream of the selected type
1001   FILE* newStream = GetOutputStream(type);
1002   fflush(newStream);
1003
1004   // redirect stream
1005   if ((type == kDebug) && (level > 0)) level--;
1006   if (type + level > GetLogLevel(module, className)) { // /dev/null
1007     if(!freopen("/dev/null", "a", stream)) AliWarning("Cannot reopen /dev/null");
1008   } else if (fOutputTypes[type] == 0) {         // stdout
1009     if (stream != stdout) dup2(fileno(stdout), fileno(stream));
1010   } else if (fOutputTypes[type] == 1) {         // stderr
1011     if (stream != stderr) dup2(fileno(stderr), fileno(stream));
1012   } else if (fOutputTypes[type] == 2) {         // file
1013     if(!freopen(fFileNames[type], "a", stream)) AliWarning(Form("Cannot reopen %s",fFileNames[type].Data()));
1014   } else if (fOutputTypes[type] == 3) {         // external C++ stream
1015     // redirection is not possible for external C++ streams
1016   }
1017
1018   // print information
1019   if (print) {
1020     PrintMessage(type, NULL, module, className, function, file, line);
1021     fflush(newStream);
1022   }
1023
1024   return original;
1025 }
1026
1027 //_____________________________________________________________________________
1028 void AliLog::RestoreStdout(Int_t original)
1029 {
1030 // restore the standard output
1031
1032   fflush(stdout);
1033   dup2(original, fileno(stdout));
1034   close(original);
1035 }
1036
1037 //_____________________________________________________________________________
1038 void AliLog::RestoreStderr(Int_t original)
1039 {
1040 // restore the standard error output
1041
1042   fflush(stderr);
1043   dup2(original, fileno(stderr));
1044   close(original);
1045 }
1046
1047
1048 //_____________________________________________________________________________
1049 ostream& AliLog::Stream(EType_t type, UInt_t level,
1050                         const char* module, const char* className,
1051                         const char* function, const char* file, Int_t line)
1052 {
1053 // get the stream object for the given output type
1054
1055   if (!fgInstance) new AliLog;
1056   return fgInstance->GetStream(type, level, module, className,
1057                                function, file, line);
1058 }
1059
1060 //_____________________________________________________________________________
1061 ostream& AliLog::GetStream(EType_t type, UInt_t level,
1062                            const char* module, const char* className,
1063                            const char* function, const char* file, Int_t line)
1064 {
1065 // get the stream object for the given output type
1066
1067   if ((type == kDebug) && (level > 0)) level--;
1068   Bool_t noOutput = (type + level > GetLogLevel(module, className));
1069
1070   if (!noOutput) {
1071     PrintMessage(type, NULL, module, className, function, file, line);
1072   }
1073   fflush(GetOutputStream(type));
1074
1075   static ofstream nullStream("/dev/null");
1076   if (noOutput) {
1077     return nullStream;
1078   } else if (fOutputTypes[type] == 0) {
1079     return cout;
1080   } else if (fOutputTypes[type] == 1) {
1081     return cerr;
1082   } else if (fOutputTypes[type] == 2) {
1083     return *fOutputStreams[type];
1084   } else if (fOutputTypes[type] == 3) {
1085     return *fOutputStreams[type];
1086   }
1087
1088   return nullStream;
1089 }
1090
1091 void  AliLog::SetStreamOutput(ostream* stream)
1092 {
1093   // set an external stream as target for log messages of all types
1094   // the external stream is completely handled by the caller, the
1095   // AliLog class just writes to it
1096
1097   for (Int_t iType = kFatal; iType < kMaxType; iType++) {
1098     SetStreamOutput((AliLog::EType_t)iType, stream);
1099   }
1100 }
1101
1102 void  AliLog::SetStreamOutput(EType_t type, ostream* stream)
1103 {
1104   // set an external stream as target for log messages of the given type
1105   // the external stream is completely handled by the caller, the
1106   // AliLog class just writes to it
1107
1108   if ((type < kFatal) || (type >= kMaxType)) return;
1109   if (!fgInstance) new AliLog;
1110   if (fgInstance->fOutputTypes[type] == 2) {
1111     fgInstance->CloseFile(type);
1112   }
1113   fgInstance->fOutputTypes[type] = 3;
1114   fgInstance->fFileNames[type] = "";
1115   fgInstance->fOutputFiles[type] = NULL;
1116   fgInstance->fOutputStreams[type] = stream;
1117 }
1118
1119 void  AliLog::SetLogNotification(AliLogNotification pCallBack)
1120 {
1121   // set a notification callback function for log messages of all types
1122
1123   for (Int_t iType = kFatal; iType < kMaxType; iType++) {
1124     SetLogNotification((AliLog::EType_t)iType, pCallBack);
1125   }
1126 }
1127
1128 void  AliLog::SetLogNotification(EType_t type, AliLogNotification pCallBack)
1129 {
1130   // set a notifications call back function for log messages of all types
1131   // the callback fuction is invoced whenever an output was written
1132   // Note: does not work for c++ streamer classes, the external stream
1133   // has to handle this diectly (e.g. custom implementation of endl)
1134
1135   if ((type < kFatal) || (type >= kMaxType)) return;
1136   if (!fgInstance) new AliLog;
1137   fgInstance->fCallBacks[type]=pCallBack;
1138 }
1139
1140 void  AliLog::PrintString(Int_t type, FILE* stream, const char* format, ...)
1141 {
1142   // this is the general method to print a log message using variadac args
1143   // to the FILE* like (C - like) streams, e.g. stdout, stderr, or files
1144   // opened by fopen.
1145   // Only in case of an external c++ ostream type output, the message is
1146   // written to that stream and the notifictaion callback is called.
1147   // The message is printed by a normal vfprintf function otherwise
1148
1149   if (format==NULL) return;
1150
1151   va_list ap;
1152   va_start(ap, format);
1153   if (fOutputTypes[type] != 3) {
1154     if (stream!=NULL) {
1155       vfprintf(stream, format, ap);
1156     }
1157   } else {
1158     // build the string and write everthing to the corresponding ostream
1159     TString fmt(format);
1160     TArrayC tgt(fmt.Length()*10); // just take a number
1161 #ifdef R__VA_COPY
1162     va_list bap;
1163     R__VA_COPY(bap, ap);
1164 #else
1165 #warning definition of R__VA_COPY has disappeared
1166 #endif //R__VA_COPY
1167
1168     Int_t iResult=0;
1169     while (1) {
1170       iResult=vsnprintf(tgt.GetArray(), tgt.GetSize(), format, ap);
1171       if (iResult==-1) {
1172         iResult=tgt.GetSize()*2;
1173       } else if (iResult<tgt.GetSize()) {
1174         break;
1175       }
1176 #ifdef R__VA_COPY
1177       if (iResult<10000) {
1178         tgt.Set(iResult+1);
1179         va_end(ap);
1180         R__VA_COPY(ap, bap);
1181       } else
1182 #endif //R__VA_COPY
1183       {
1184         tgt[tgt.GetSize()-1]=0;
1185         break;
1186       }
1187     }
1188 #ifdef R__VA_COPY
1189     va_end(bap);
1190 #endif //R__VA_COPY
1191
1192     if (fOutputStreams[type]) {
1193       *(fOutputStreams[type]) << tgt.GetArray();
1194     }
1195   }
1196   va_end(ap);
1197 }
1198
1199
1200 void AliLog::MakeCoreDump(const char *fout){
1201   //
1202   // Functionality to make a program snapshot
1203   //   gcore - Generate a core file for a running process
1204   //   gcore dmake a current snapshot, program can continue further
1205   //   We assum that gcore is installed
1206   //   for details see:  man gcore
1207   //
1208   // Example use - make default core file for current process:  AliLog::MakeCoreDump(0)
1209   //
1210   //
1211   // Automatic core dump creation in case of the AliFatal can be specified using
1212   // static void  EnableCoreDump(Bool_t enabled);
1213   // Core dump is created in addition to the stack trace ()
1214   // marian.ivanov@cern.ch
1215   //
1216   if (!gSystem) return;
1217   printf("AliLog::MakeCoreDump\n");
1218   if (fout){
1219     gSystem->Exec(Form("gcore -o %s  %d",fout, gSystem->GetPid()));
1220   }else{
1221     gSystem->Exec(Form("gcore   %d", gSystem->GetPid()));
1222   }
1223 }