1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 ///////////////////////////////////////////////////////////////////////////////
20 // class for logging debug, info and error messages //
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 //
26 // It also handles the messages produces by the preprocessor macros defined //
27 // in the header file: AliDebug, AliInfo, AliWarning, AliError, AliFatal. //
29 // More details about the message logging can be found on the ALICE Offline //
32 ///////////////////////////////////////////////////////////////////////////////
36 #include <Riostream.h>
42 #include <Varargs.h> // platform independent definition of va_copy
54 // implementation of a singleton here
55 AliLog* AliLog::fgInstance = NULL;
57 Bool_t AliLog::fgDebugEnabled = kTRUE;
58 Bool_t AliLog::fgCoreEnabled = kFALSE;
61 * get root logger singleton instance
63 AliLog *AliLog::GetRootLogger()
65 if (fgInstance == NULL)
68 fgInstance = new AliLog;
75 * delete the root logger singleton instance
77 void AliLog::DeleteRootLogger()
79 if (fgInstance != NULL)
87 * default private constructor
91 fGlobalLogLevel(kInfo),
94 fPrintRepetitions(kTRUE),
104 // default constructor: set default values
106 for (Int_t iType = kFatal; iType < kMaxType; iType++)
108 fOutputTypes[iType] = 0;
109 fFileNames[iType] = "";
110 fOutputFiles[iType] = NULL;
111 fOutputStreams[iType] = NULL;
112 fCallBacks[iType]=NULL;
114 fPrintType[iType] = kTRUE;
115 fPrintModule[iType] = kFALSE;
116 fPrintScope[iType] = kTRUE;
117 fPrintLocation[iType] = (iType == kDebug);
121 // replace the previous instance by this one
122 if (fgInstance) delete fgInstance;
125 SetHandleRootMessages(kTRUE);
127 // read the .rootrc settings
136 // destructor: clean up and reset instance pointer
138 if (fRepetitions > 0) PrintRepetitions();
140 for (Int_t i = 0; i < fModuleDebugLevels.GetEntriesFast(); i++)
142 if (fModuleDebugLevels[i]) fModuleDebugLevels[i]->Delete();
145 fClassDebugLevels.Delete();
147 for (Int_t i = 0; i < fClassDebugLevels.GetEntriesFast(); i++)
149 if (fClassDebugLevels[i]) fClassDebugLevels[i]->Delete();
152 fClassDebugLevels.Delete();
154 for (Int_t iType = kFatal; iType < kMaxType; iType++)
166 //_____________________________________________________________________________
167 AliLog::AliLog(const AliLog& 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)
184 Fatal("AliLog", "copy constructor not implemented");
188 //_____________________________________________________________________________
189 AliLog& AliLog::operator = (const AliLog& /*log*/)
191 // assignment operator
193 Fatal("operator =", "assignment operator not implemented");
199 * gSystem see TSystem.h
202 * LOG_NO_DEBUG: fgDebugEnabled <- false
203 * AliRoot.AliLog.EnableDebug
204 * AliRoot.AliLog.GlobalLogLevel
206 //_____________________________________________________________________________
207 void AliLog::ReadEnvSettings()
209 // load settings from the root configuration file (.rootrc)
210 // and from environment variables
212 static const char* typeNames[kMaxType] = {"kFatal", "kError", "kWarning", "kInfo", "kDebug"};
214 // debug en- or disabling
215 if (gSystem->Getenv("LOG_NO_DEBUG"))
217 fgDebugEnabled = kFALSE;
219 else if (gEnv->Defined("AliRoot.AliLog.EnableDebug"))
221 fgDebugEnabled = gEnv->GetValue("AliRoot.AliLog.EnableDebug", fgDebugEnabled);
222 AliInfo(Form("debug %sabled", ((fgDebugEnabled) ? "en" : "dis")));
226 if (gEnv->Defined("AliRoot.AliLog.GlobalLogLevel"))
228 const char* type = gEnv->GetValue("AliRoot.AliLog.GlobalLogLevel", "");
230 for (Int_t iType = kFatal; iType < kMaxType; iType++)
232 if (strcmp(type, typeNames[iType]) == 0) fGlobalLogLevel = iType;
235 AliDebug(3, Form("global log level set to %d", fGlobalLogLevel));
238 // global debug level
239 if (gEnv->Defined("AliRoot.AliLog.GlobalDebugLevel"))
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));
247 // module debug level
248 if (gEnv->Defined("AliRoot.AliLog.ModuleDebugLevel"))
250 TString levels = gEnv->GetValue("AliRoot.AliLog.ModuleDebugLevel", "");
251 char* p = const_cast<char*>(levels.Data());
253 while (const char* module = strtok(p, " "))
256 char* pos = const_cast<char*>(index(module, ':'));
259 Int_t level = atoi(pos);
260 SetModuleDebugLevel(module, level);
261 AliDebug(3, Form("debug level for module %s set to %d", module, level));
266 if (gEnv->Defined("AliRoot.AliLog.ClassDebugLevel"))
268 TString levels = gEnv->GetValue("AliRoot.AliLog.ClassDebugLevel", "");
269 char* p = const_cast<char*>(levels.Data());
271 while (const char* className = strtok(p, " "))
274 char* pos = const_cast<char*>(index(className, ':'));
277 Int_t level = atoi(pos);
278 SetClassDebugLevel(className, level);
279 AliDebug(3, Form("debug level for class %s set to %d", className, level));
283 // general output stream
284 if (gEnv->Defined("AliRoot.AliLog.Output"))
286 TString stream = gEnv->GetValue("AliRoot.AliLog.Output", "Standard");
288 if (stream.CompareTo("standard", TString::kIgnoreCase) == 0)
291 AliDebug(3, "output stream set to standard output for all types");
293 else if (stream.CompareTo("error", TString::kIgnoreCase) == 0)
296 AliDebug(3, "output stream set to error output for all types");
298 else if (!stream.IsNull())
300 SetFileOutput(stream);
301 AliDebug(3, Form("output stream set to file %s for all types", stream.Data()));
305 // individual output streams
306 for (Int_t iType = kFatal; iType < kMaxType; iType++)
308 TString name("AliRoot.AliLog.Output.");
309 name += &typeNames[iType][1];
311 if (gEnv->Defined(name))
313 TString stream = gEnv->GetValue(name, "Standard");
315 if (stream.CompareTo("standard", TString::kIgnoreCase) == 0)
317 SetStandardOutput(EType_t(iType));
318 AliDebug(3, Form("output stream set to standard output for type %s", typeNames[iType]));
320 else if (stream.CompareTo("error", TString::kIgnoreCase) == 0)
322 SetErrorOutput(EType_t(iType));
323 AliDebug(3, Form("output stream set to error output for type %s", typeNames[iType]));
325 else if (!stream.IsNull())
327 SetFileOutput(EType_t(iType), stream);
328 AliDebug(3, Form("output stream set to file %s for type %s", stream.Data(), typeNames[iType]));
333 // handling of root error messages
334 if (gEnv->Defined("AliRoot.AliLog.HandleRootMessages"))
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")));
342 static const char* settingNames[4] = {"Type", "Module", "Scope", "Location"};
343 Bool_t* settings[] = {fPrintType, fPrintModule, fPrintScope, fPrintLocation};
345 for (Int_t iSetting = 0; iSetting < 4; iSetting++)
347 TString name("AliRoot.AliLog.Print");
348 name += settingNames[iSetting];
350 if (gEnv->Defined(name))
352 Bool_t on = gEnv->GetValue(name, settings[iSetting][0]);
354 for (Int_t iType = kFatal; iType < kMaxType; iType++)
356 settings[iSetting][iType] = on;
358 AliDebug(3, Form("printing of %s %sabled for all types", settingNames[iSetting], ((on) ? "en" : "dis")));
361 for (Int_t iType = kFatal; iType < kMaxType; iType++)
363 TString nameType = name + "." + &typeNames[iType][1];
365 if (gEnv->Defined(nameType))
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]));
374 // repetition of messages
375 if (gEnv->Defined("AliRoot.AliLog.PrintRepetitions"))
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")));
381 if (gSystem->Getenv("ALIROOT_FORCE_COREDUMP")){
382 EnableCoreDump(kTRUE);
388 //_____________________________________________________________________________
389 void AliLog::RootErrorHandler(Int_t level, Bool_t abort,
390 const char* location, const char* message)
392 // new error handler for messages from root
396 case ::kFatal : level = kFatal; break;
398 DefaultErrorHandler(level, abort, location, message);
401 DefaultErrorHandler(level, abort, location, message);
403 case ::kError : level = kError; break;
404 case ::kWarning : level = kWarning; break;
405 case ::kInfo : level = kInfo; break;
406 default : level = kDebug; break;
408 AliLog::Message(level, message, "ROOT", NULL, location, NULL, 0);
412 // DEPRECATED: USE A CONFIGURATION FILE INSTEAD
413 //_____________________________________________________________________________
414 void AliLog::EnableDebug(Bool_t enabled)
416 // enable or disable debug output
418 fgDebugEnabled = enabled;
421 void AliLog::EnableCoreDump(Bool_t enabled)
423 // enable or disable debug output
425 fgCoreEnabled = enabled;
426 gSystem->ResetSignal(kSigFloatingException,enabled);
427 gSystem->ResetSignal(kSigSegmentationViolation,enabled);
428 if (enabled) printf("Core dump enabled\n");
430 printf("Core dump disabled\n");
436 //_____________________________________________________________________________
437 void AliLog::SetGlobalLogLevel(EType_t type)
439 // set the global debug level
442 if (!fgInstance) new AliLog;
443 fgInstance->fGlobalLogLevel = type;
446 //_____________________________________________________________________________
447 Int_t AliLog::GetGlobalLogLevel()
449 // get the global debug level
451 if (!fgInstance) new AliLog;
452 return fgInstance->fGlobalLogLevel;
455 //_____________________________________________________________________________
456 void AliLog::SetGlobalDebugLevel(Int_t level)
458 // set the global debug level
460 if (!fgInstance) new AliLog;
461 if (level < -kDebugOffset) level = -kDebugOffset;
462 fgInstance->fGlobalLogLevel = kDebugOffset + level;
465 //_____________________________________________________________________________
466 Int_t AliLog::GetGlobalDebugLevel()
468 // get the global debug level
470 if (!fgInstance) new AliLog;
471 return fgInstance->fGlobalLogLevel - kDebugOffset;
474 //_____________________________________________________________________________
475 void AliLog::SetModuleDebugLevel(const char* module, Int_t level)
477 // set the debug level for the given module
480 if (!fgInstance) new AliLog;
481 TObject* obj = fgInstance->fModuleDebugLevels.FindObject(module);
483 obj = new TNamed(module, module);
484 fgInstance->fModuleDebugLevels.Add(obj);
486 level += kDebugOffset;
487 if (level < kFatal) level = kFatal;
488 obj->SetUniqueID(level);
491 //_____________________________________________________________________________
492 void AliLog::ClearModuleDebugLevel(const char* module)
494 // remove the setting of the debug level for the given module
497 if (!fgInstance) new AliLog;
498 TObject* obj = fgInstance->fModuleDebugLevels.FindObject(module);
499 if (obj) delete fgInstance->fModuleDebugLevels.Remove(obj);
502 //_____________________________________________________________________________
503 void AliLog::SetClassDebugLevel(const char* className, Int_t level)
505 // set the debug level for the given class
507 if (!className) return;
508 if (!fgInstance) new AliLog;
509 TObject* obj = fgInstance->fClassDebugLevels.FindObject(className);
511 obj = new TNamed(className, className);
512 fgInstance->fClassDebugLevels.Add(obj);
514 level += kDebugOffset;
515 if (level < kFatal) level = kFatal;
516 obj->SetUniqueID(level);
519 //_____________________________________________________________________________
520 void AliLog::ClearClassDebugLevel(const char* className)
522 // remove the setting of the debug level for the given class
524 if (!className) return;
525 if (!fgInstance) new AliLog;
526 TObject* obj = fgInstance->fClassDebugLevels.FindObject(className);
527 if (obj) delete fgInstance->fClassDebugLevels.Remove(obj);
531 //_____________________________________________________________________________
532 void AliLog::SetStandardOutput()
534 // write all log messages to the standard output (stdout)
536 if (!fgInstance) new AliLog;
537 for (Int_t iType = kFatal; iType < kMaxType; iType++) {
538 fgInstance->CloseFile(iType);
539 fgInstance->fOutputTypes[iType] = 0;
543 //_____________________________________________________________________________
544 void AliLog::SetStandardOutput(EType_t type)
546 // write log messages of the given type to the standard output (stdout)
548 if ((type < kFatal) || (type >= kMaxType)) return;
549 if (!fgInstance) new AliLog;
550 fgInstance->CloseFile(type);
551 fgInstance->fOutputTypes[type] = 0;
554 //_____________________________________________________________________________
555 void AliLog::SetErrorOutput()
557 // write all log messages to the error output (stderr)
559 if (!fgInstance) new AliLog;
560 for (Int_t iType = kFatal; iType < kMaxType; iType++) {
561 fgInstance->CloseFile(iType);
562 fgInstance->fOutputTypes[iType] = 1;
566 //_____________________________________________________________________________
567 void AliLog::SetErrorOutput(EType_t type)
569 // write log messages of the given type to the error output (stderr)
571 if ((type < kFatal) || (type >= kMaxType)) return;
572 if (!fgInstance) new AliLog;
573 fgInstance->CloseFile(type);
574 fgInstance->fOutputTypes[type] = 1;
577 //_____________________________________________________________________________
578 void AliLog::SetFileOutput(const char* fileName)
580 // write all log messages to the given file
582 if (!fgInstance) new AliLog;
583 for (Int_t iType = kFatal; iType < kMaxType; iType++) {
584 if ((fgInstance->fOutputTypes[iType] == 2) &&
585 (fgInstance->fFileNames[iType].CompareTo(fileName) != 0)) {
586 fgInstance->CloseFile(iType);
588 fgInstance->fOutputTypes[iType] = 2;
589 fgInstance->fFileNames[iType] = fileName;
590 fgInstance->fOutputFiles[iType] = NULL;
591 fgInstance->fOutputStreams[iType] = NULL;
595 //_____________________________________________________________________________
596 void AliLog::SetFileOutput(EType_t type, const char* fileName)
598 // write log messages of the given type to the given file
600 if ((type < kFatal) || (type >= kMaxType)) return;
601 if (!fgInstance) new AliLog;
602 if ((fgInstance->fOutputTypes[type] == 2) &&
603 (fgInstance->fFileNames[type].CompareTo(fileName) != 0)) {
604 fgInstance->CloseFile(type);
606 fgInstance->fOutputTypes[type] = 2;
607 fgInstance->fFileNames[type] = fileName;
608 fgInstance->fOutputFiles[type] = NULL;
609 fgInstance->fOutputStreams[type] = NULL;
612 //_____________________________________________________________________________
613 void AliLog::CloseFile(Int_t type)
615 // close the file for the given type if needed
617 if ((fOutputTypes[type] == 2) && fOutputFiles[type]) {
618 Bool_t closeFile = kTRUE;
619 for (Int_t iType = kFatal; iType < kMaxType; iType++) {
620 if ((iType != type) && (fOutputFiles[iType] == fOutputFiles[type])) {
625 fclose(fOutputFiles[type]);
626 ofstream* stream=reinterpret_cast<ofstream*>(fOutputStreams[type]);
628 delete fOutputStreams[type];
631 fOutputFiles[type] = NULL;
632 fOutputStreams[type] = NULL;
633 fFileNames[type] = "";
634 fOutputTypes[type] = 0;
637 //_____________________________________________________________________________
638 FILE* AliLog::GetOutputStream(Int_t type)
640 // get the output stream for the given type of messages
642 if (type > kDebug) type = kDebug;
643 if (fOutputTypes[type] == 0) return stdout;
644 else if (fOutputTypes[type] == 1) return stderr;
645 else if (fOutputTypes[type] == 2) {
646 if (!fOutputFiles[type]) {
648 ostream* stream = NULL;
649 if (!fFileNames[type].IsNull()) {
650 for (Int_t iType = kFatal; iType < kMaxType; iType++) {
651 if ((iType != type) &&
652 (fFileNames[iType].CompareTo(fFileNames[type]) == 0) &&
653 fOutputFiles[iType]) {
654 file = fOutputFiles[iType];
655 stream = fOutputStreams[iType];
660 file = fopen(fFileNames[type], "a");
661 stream = new ofstream(fFileNames[type], ios::app);
664 fOutputFiles[type] = file;
665 fOutputStreams[type] = stream;
666 if (!file) CloseFile(type);
668 if (fOutputFiles[type]) return fOutputFiles[type];
674 //_____________________________________________________________________________
677 // flush the output streams
679 if (!fgInstance) new AliLog;
680 for (Int_t iType = kFatal; iType < kMaxType; iType++) {
681 if (fgInstance->fOutputFiles[iType]) {
682 fflush(fgInstance->fOutputFiles[iType]);
683 fgInstance->fOutputStreams[iType]->flush();
691 //_____________________________________________________________________________
692 void AliLog::SetHandleRootMessages(Bool_t on)
694 // enable or disable the handling of messages form root
696 if (!fgInstance) new AliLog;
698 SetErrorHandler(RootErrorHandler);
700 SetErrorHandler(DefaultErrorHandler);
705 //_____________________________________________________________________________
706 void AliLog::SetPrintType(Bool_t on)
708 // switch on or off the printing of the message type for all message types
710 if (!fgInstance) new AliLog;
711 for (Int_t iType = kFatal; iType < kMaxType; iType++) {
712 fgInstance->fPrintType[iType] = on;
716 //_____________________________________________________________________________
717 void AliLog::SetPrintType(EType_t type, Bool_t on)
719 // switch on or off the printing of the message type for the given message type
721 if ((type < kFatal) || (type >= kMaxType)) return;
722 if (!fgInstance) new AliLog;
723 fgInstance->fPrintType[type] = on;
726 //_____________________________________________________________________________
727 void AliLog::SetPrintModule(Bool_t on)
729 // switch on or off the printing of the module for all message types
731 if (!fgInstance) new AliLog;
732 for (Int_t iType = kFatal; iType < kMaxType; iType++) {
733 fgInstance->fPrintModule[iType] = on;
737 //_____________________________________________________________________________
738 void AliLog::SetPrintModule(EType_t type, Bool_t on)
740 // switch on or off the printing of the module for the given message type
742 if ((type < kFatal) || (type >= kMaxType)) return;
743 if (!fgInstance) new AliLog;
744 fgInstance->fPrintModule[type] = on;
747 //_____________________________________________________________________________
748 void AliLog::SetPrintScope(Bool_t on)
750 // switch on or off the printing of the scope/class name for all message types
752 if (!fgInstance) new AliLog;
753 for (Int_t iType = kFatal; iType < kMaxType; iType++) {
754 fgInstance->fPrintScope[iType] = on;
758 //_____________________________________________________________________________
759 void AliLog::SetPrintScope(EType_t type, Bool_t on)
761 // switch on or off the printing of the scope/class name
762 // for the given message type
764 if ((type < kFatal) || (type >= kMaxType)) return;
765 if (!fgInstance) new AliLog;
766 fgInstance->fPrintScope[type] = on;
769 //_____________________________________________________________________________
770 void AliLog::SetPrintLocation(Bool_t on)
772 // switch on or off the printing of the file name and line number
773 // for all message types
775 if (!fgInstance) new AliLog;
776 for (Int_t iType = kFatal; iType < kMaxType; iType++) {
777 fgInstance->fPrintLocation[iType] = on;
781 //_____________________________________________________________________________
782 void AliLog::SetPrintLocation(EType_t type, Bool_t on)
784 // switch on or off the printing of the file name and line number
785 // for the given message type
787 if ((type < kFatal) || (type >= kMaxType)) return;
788 if (!fgInstance) new AliLog;
789 fgInstance->fPrintLocation[type] = on;
793 //_____________________________________________________________________________
794 void AliLog::SetPrintRepetitions(Bool_t on)
796 // switch on or off the printing of the number of repetitions of a message
797 // instead of repeating the same message
799 if (!fgInstance) new AliLog;
800 if (!on && (fgInstance->fRepetitions > 0)) fgInstance->PrintRepetitions();
801 fgInstance->fPrintRepetitions = on;
805 //_____________________________________________________________________________
806 void AliLog::WriteToFile(const char* name, Int_t option)
808 // write the log object with the given name and option to the current file
810 if (!fgInstance) new AliLog;
811 fgInstance->TObject::Write(name, option);
815 //_____________________________________________________________________________
816 UInt_t AliLog::GetLogLevel(const char* module, const char* className) const
818 // get the logging level for the given module and class
820 if (!fgInstance) new AliLog;
822 TObject* obj = fgInstance->fClassDebugLevels.FindObject(className);
823 if (obj) return obj->GetUniqueID();
826 TObject* obj = fgInstance->fModuleDebugLevels.FindObject(module);
827 if (obj) return obj->GetUniqueID();
829 return fgInstance->fGlobalLogLevel;
832 //_____________________________________________________________________________
833 Int_t AliLog::GetDebugLevel(const char* module, const char* className)
835 // get the debug level for the given module and class
837 if (!fgInstance) new AliLog;
838 return fgInstance->GetLogLevel(module, className) - kDebugOffset;
841 //_____________________________________________________________________________
842 void AliLog::PrintMessage(UInt_t type, const char* message,
843 const char* module, const char* className,
844 const char* function, const char* file, Int_t line)
846 // print the given message
848 // don't print the message if it is repeated
849 if (fPrintRepetitions &&
850 (fLastType == type) &&
851 (message && (fLastMessage.CompareTo(message) == 0)) &&
852 ((module && (fLastModule.CompareTo(module) == 0)) ||
853 (!module && fLastModule.IsNull())) &&
854 ((className && (fLastClassName.CompareTo(className) == 0)) ||
855 (!className && fLastClassName.IsNull())) &&
856 ((function && (fLastFunction.CompareTo(function) == 0)) ||
857 (!function && fLastFunction.IsNull()))&&
858 ((file && (fLastFile.CompareTo(file) == 0)) ||
859 (!file && fLastFile.IsNull())) &&
860 (fLastLine == line)) {
865 // print number of repetitions
866 if (fRepetitions > 0) PrintRepetitions();
868 // remember this message
871 fLastMessage = message;
872 fLastModule = module;
873 fLastClassName = className;
874 fLastFunction = function;
879 FILE* stream = GetOutputStream(type);
880 static const char* typeNames[kMaxType] =
881 {"Fatal", "Error", "Warning", "Info", "Debug"};
883 if (fPrintType[type]) {
884 PrintString(type, stream, "%c-", typeNames[type][0]);
886 if (fPrintModule[type] && module) {
887 PrintString(type, stream, "%s/", module);
889 if (fPrintScope[type] && className) {
890 PrintString(type, stream, "%s::", className);
893 PrintString(type, stream, "%s: %s", function, message);
895 PrintString(type, stream, "%s", function);
897 if (fPrintLocation[type] && file) {
898 PrintString(type, stream, " (%s:%.0d)", file, line);
901 PrintString(type, stream, "\n");
903 PrintString(type, stream, ": ");
905 if (fCallBacks[type]) (*(fCallBacks[type]))((EType_t)type, NULL);
908 //_____________________________________________________________________________
909 void AliLog::PrintRepetitions()
911 // print number of repetitions
913 PrintString(fLastType, GetOutputStream(fLastType), " <message repeated %d time%s>\n",
914 fRepetitions, (fRepetitions > 1) ? "s" : "");
915 if (fCallBacks[fLastType]) (*(fCallBacks[fLastType]))((EType_t)fLastType, NULL);
918 //_____________________________________________________________________________
919 void AliLog::Message(UInt_t level, const char* message,
920 const char* module, const char* className,
921 const char* function, const char* file, Int_t line)
923 // print a log message
925 if (!fgInstance) new AliLog;
927 // get the message type
929 if (type >= kMaxType) type = kMaxType - 1;
931 // print the message if the debug level allows
932 if (level <= fgInstance->GetLogLevel(module, className)) {
933 fgInstance->PrintMessage(type, message,
934 module, className, function, file, line);
937 // abort in case of a fatal message
938 if (type == kFatal) {
941 gSystem->StackTrace();
942 if (fgCoreEnabled) MakeCoreDump("core.AliRoot");
945 if (fgCoreEnabled) MakeCoreDump("core.AliRoot");
953 //_____________________________________________________________________________
954 void AliLog::Debug(UInt_t level, const char* message,
955 const char* module, const char* className,
956 const char* function, const char* file, Int_t line)
958 // print a debug message
960 if (level == 0) level = 1;
961 level += kDebugOffset;
962 Message(level, message, module, className, function, file, line);
966 //_____________________________________________________________________________
967 Int_t AliLog::RedirectStdoutTo(EType_t type, UInt_t level, const char* module,
968 const char* className, const char* function,
969 const char* file, Int_t line, Bool_t print)
971 // redirect the standard output to the stream of the given type
973 if (!fgInstance) new AliLog;
974 return fgInstance->RedirectTo(stdout, type, level, module, className,
975 function, file, line, print);
978 //_____________________________________________________________________________
979 Int_t AliLog::RedirectStderrTo(EType_t type, UInt_t level, const char* module,
980 const char* className, const char* function,
981 const char* file, Int_t line, Bool_t print)
983 // redirect the standard error output to the stream of the given type
985 if (!fgInstance) new AliLog;
986 return fgInstance->RedirectTo(stderr, type, level, module, className,
987 function, file, line, print);
990 //_____________________________________________________________________________
991 Int_t AliLog::RedirectTo(FILE* stream, EType_t type, UInt_t level,
992 const char* module, const char* className,
993 const char* function, const char* file, Int_t line,
996 // redirect the standard (error) output stream to the stream of the given type
998 // get the original file descriptor to be able to restore it later
999 Int_t original = dup(fileno(stream));
1002 // flush the stream of the selected type
1003 FILE* newStream = GetOutputStream(type);
1007 if ((type == kDebug) && (level > 0)) level--;
1008 if (type + level > GetLogLevel(module, className)) { // /dev/null
1009 if(!freopen("/dev/null", "a", stream)) AliWarning("Cannot reopen /dev/null");
1010 } else if (fOutputTypes[type] == 0) { // stdout
1011 if (stream != stdout) dup2(fileno(stdout), fileno(stream));
1012 } else if (fOutputTypes[type] == 1) { // stderr
1013 if (stream != stderr) dup2(fileno(stderr), fileno(stream));
1014 } else if (fOutputTypes[type] == 2) { // file
1015 if(!freopen(fFileNames[type], "a", stream)) AliWarning(Form("Cannot reopen %s",fFileNames[type].Data()));
1016 } else if (fOutputTypes[type] == 3) { // external C++ stream
1017 // redirection is not possible for external C++ streams
1020 // print information
1022 PrintMessage(type, NULL, module, className, function, file, line);
1029 //_____________________________________________________________________________
1030 void AliLog::RestoreStdout(Int_t original)
1032 // restore the standard output
1035 dup2(original, fileno(stdout));
1039 //_____________________________________________________________________________
1040 void AliLog::RestoreStderr(Int_t original)
1042 // restore the standard error output
1045 dup2(original, fileno(stderr));
1050 //_____________________________________________________________________________
1051 ostream& AliLog::Stream(EType_t type, UInt_t level,
1052 const char* module, const char* className,
1053 const char* function, const char* file, Int_t line)
1055 // get the stream object for the given output type
1057 if (!fgInstance) new AliLog;
1058 return fgInstance->GetStream(type, level, module, className,
1059 function, file, line);
1062 //_____________________________________________________________________________
1063 ostream& AliLog::GetStream(EType_t type, UInt_t level,
1064 const char* module, const char* className,
1065 const char* function, const char* file, Int_t line)
1067 // get the stream object for the given output type
1069 if ((type == kDebug) && (level > 0)) level--;
1070 Bool_t noOutput = (type + level > GetLogLevel(module, className));
1073 PrintMessage(type, NULL, module, className, function, file, line);
1075 fflush(GetOutputStream(type));
1077 static ofstream nullStream("/dev/null");
1080 } else if (fOutputTypes[type] == 0) {
1082 } else if (fOutputTypes[type] == 1) {
1084 } else if (fOutputTypes[type] == 2) {
1085 return *fOutputStreams[type];
1086 } else if (fOutputTypes[type] == 3) {
1087 return *fOutputStreams[type];
1093 void AliLog::SetStreamOutput(ostream* stream)
1095 // set an external stream as target for log messages of all types
1096 // the external stream is completely handled by the caller, the
1097 // AliLog class just writes to it
1099 for (Int_t iType = kFatal; iType < kMaxType; iType++) {
1100 SetStreamOutput((AliLog::EType_t)iType, stream);
1104 void AliLog::SetStreamOutput(EType_t type, ostream* stream)
1106 // set an external stream as target for log messages of the given type
1107 // the external stream is completely handled by the caller, the
1108 // AliLog class just writes to it
1110 if ((type < kFatal) || (type >= kMaxType)) return;
1111 if (!fgInstance) new AliLog;
1112 if (fgInstance->fOutputTypes[type] == 2) {
1113 fgInstance->CloseFile(type);
1115 fgInstance->fOutputTypes[type] = 3;
1116 fgInstance->fFileNames[type] = "";
1117 fgInstance->fOutputFiles[type] = NULL;
1118 fgInstance->fOutputStreams[type] = stream;
1121 void AliLog::SetLogNotification(AliLogNotification pCallBack)
1123 // set a notification callback function for log messages of all types
1125 for (Int_t iType = kFatal; iType < kMaxType; iType++) {
1126 SetLogNotification((AliLog::EType_t)iType, pCallBack);
1130 void AliLog::SetLogNotification(EType_t type, AliLogNotification pCallBack)
1132 // set a notifications call back function for log messages of all types
1133 // the callback fuction is invoced whenever an output was written
1134 // Note: does not work for c++ streamer classes, the external stream
1135 // has to handle this diectly (e.g. custom implementation of endl)
1137 if ((type < kFatal) || (type >= kMaxType)) return;
1138 if (!fgInstance) new AliLog;
1139 fgInstance->fCallBacks[type]=pCallBack;
1142 void AliLog::PrintString(Int_t type, FILE* stream, const char* format, ...)
1144 // this is the general method to print a log message using variadac args
1145 // to the FILE* like (C - like) streams, e.g. stdout, stderr, or files
1147 // Only in case of an external c++ ostream type output, the message is
1148 // written to that stream and the notifictaion callback is called.
1149 // The message is printed by a normal vfprintf function otherwise
1151 if (format==NULL) return;
1154 va_start(ap, format);
1155 if (fOutputTypes[type] != 3) {
1157 vfprintf(stream, format, ap);
1160 // build the string and write everthing to the corresponding ostream
1161 TString fmt(format);
1162 TArrayC tgt(fmt.Length()*10); // just take a number
1165 R__VA_COPY(bap, ap);
1167 #warning definition of R__VA_COPY has disappeared
1172 iResult=vsnprintf(tgt.GetArray(), tgt.GetSize(), format, ap);
1174 iResult=tgt.GetSize()*2;
1175 } else if (iResult<tgt.GetSize()) {
1179 if (iResult<10000) {
1182 R__VA_COPY(ap, bap);
1186 tgt[tgt.GetSize()-1]=0;
1194 if (fOutputStreams[type]) {
1195 *(fOutputStreams[type]) << tgt.GetArray();
1202 void AliLog::MakeCoreDump(const char *fout){
1204 // Functionality to make a program snapshot
1205 // gcore - Generate a core file for a running process
1206 // gcore dmake a current snapshot, program can continue further
1207 // We assum that gcore is installed
1208 // for details see: man gcore
1210 // Example use - make default core file for current process: AliLog::MakeCoreDump(0)
1213 // Automatic core dump creation in case of the AliFatal can be specified using
1214 // static void EnableCoreDump(Bool_t enabled);
1215 // Core dump is created in addition to the stack trace ()
1216 // marian.ivanov@cern.ch
1218 if (!gSystem) return;
1219 printf("AliLog::MakeCoreDump\n");
1221 gSystem->Exec(Form("gcore -o %s %d",fout, gSystem->GetPid()));
1223 gSystem->Exec(Form("gcore %d", gSystem->GetPid()));