HLT/BASE/AliHLTLogging.cxx

   1 // $Id$
   2
   3 ///**************************************************************************
   4 ///* This file is property of and copyright by the                          *
   5 ///* ALICE Experiment at CERN, All rights reserved.                         *
   6 ///*                                                                        *
   7 ///* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
   8 ///*                  for The ALICE HLT Project.                            *
   9 ///*                                                                        *
  10 ///* Permission to use, copy, modify and distribute this software and its   *
  11 ///* documentation strictly for non-commercial purposes is hereby granted   *
  12 ///* without fee, provided that the above copyright notice appears in all   *
  13 ///* copies and that both the copyright notice and this permission notice   *
  14 ///* appear in the supporting documentation. The authors make no claims     *
  15 ///* about the suitability of this software for any purpose. It is          *
  16 ///* provided "as is" without express or implied warranty.                  *
  17 ///**************************************************************************
  18
  19 /// @file   AliHLTLogging.cxx
  20 /// @author Matthias Richter, Timm Steinbeck
  21 /// @date
  22 /// @brief  Implementation of HLT logging primitives.
  23 ///
  24
  25 #include "AliHLTStdIncludes.h"
  26 #include "AliHLTLogging.h"
  27 #include "AliHLTComponentHandler.h"
  28 #include "TString.h"
  29 #include "Varargs.h"
  30 #include <string>
  31 #include <sstream>
  32 #include <iostream>
  33
  34 using std::cout;
  35 using std::cerr;
  36 using std::endl;
  37
  38 /** ROOT macro for the implementation of ROOT specific class methods */
  39 ClassImp(AliHLTLogging);
  40
  41 AliHLTLogging::AliHLTLogging()
  42   :
  43   fLocalLogFilter(fgLocalLogDefault),
  44   fpDefaultKeyword(NULL),
  45   fpCurrentKeyword(NULL)
  46 {
  47   // see header file for class documentation
  48   // or
  49   // refer to README to build package
  50   // or
  51   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  52 }
  53
  54 AliHLTLogging::AliHLTLogging(const AliHLTLogging&)
  55   :
  56   fLocalLogFilter(kHLTLogAll),
  57   fpDefaultKeyword(NULL),
  58   fpCurrentKeyword(NULL)
  59 {
  60   // see header file for class documentation
  61   HLTFatal("copy constructor untested");
  62 }
  63
  64 AliHLTLogging& AliHLTLogging::operator=(const AliHLTLogging&)
  65 {
  66   // see header file for class documentation
  67   HLTFatal("assignment operator untested");
  68   return *this;
  69 }
  70
  71 ostringstream AliHLTLogging::fgLogstr;
  72 AliHLTComponentLogSeverity AliHLTLogging::fgGlobalLogFilter=kHLTLogAll;
  73 AliHLTComponentLogSeverity AliHLTLogging::fgLocalLogDefault=kHLTLogAll;
  74 AliHLTfctLogging AliHLTLogging::fgLoggingFunc=NULL;
  75 AliHLTLogging::AliHLTDynamicMessage AliHLTLogging::fgAliLoggingFunc=NULL;
  76 int AliHLTLogging::fgUseAliLog=1;
  77
  78 TString AliHLTLogging::fgBlackList="";
  79 TString AliHLTLogging::fgWhiteList="";
  80
  81 AliHLTLogging::~AliHLTLogging()
  82 {
  83   // see header file for class documentation
  84 }
  85
  86 // the array will be grown dynamically, this is just an initial size
  87 TArrayC AliHLTLogging::fgAliHLTLoggingTarget(200);
  88 // the maximum size of the array
  89 const int AliHLTLogging::fgkALIHLTLOGGINGMAXBUFFERSIZE=10000;
  90
  91 int AliHLTLogging::Init(AliHLTfctLogging pFun)
  92 {
  93   // see header file for class documentation
  94   if (fgLoggingFunc!=NULL && fgLoggingFunc!=pFun) {
  95     (*fgLoggingFunc)(NULL/*fParam*/, kHLTLogWarning, "AliHLTLogging::Init", "no key", "overriding previously initialized logging function");
  96   }
  97   fgLoggingFunc=pFun;
  98
  99   return 0;
 100 }
 101
 102 int AliHLTLogging::InitAliLogTrap(AliHLTComponentHandler* pHandler)
 103 {
 104   // see header file for class documentation
 105   // init the AliRoot logging trap
 106   // AliLog messages are redirected to PubSub,
 107   int iResult=0;
 108   if (pHandler) {
 109     // set temporary loglevel of component handler
 110     AliHLTComponentLogSeverity loglevel=pHandler->GetLocalLoggingLevel();
 111     pHandler->SetLocalLoggingLevel(kHLTLogError);
 112
 113     // load library containing AliRoot dependencies and initialization handler
 114     pHandler->LoadLibrary(ALILOG_WRAPPER_LIBRARY, 0/* do not activate agents */);
 115
 116     // restore loglevel
 117     pHandler->SetLocalLoggingLevel(loglevel);
 118
 119     // find the symbol
 120     InitAliDynamicMessageCallback pFunc=(InitAliDynamicMessageCallback)pHandler->FindSymbol(ALILOG_WRAPPER_LIBRARY, "InitAliDynamicMessageCallback");
 121     if (pFunc) {
 122       iResult=(*pFunc)();
 123     } else {
 124       Message(NULL, kHLTLogError, "AliHLTLogging::InitAliLogTrap", "init logging",
 125               "can not initialize AliLog callback");
 126       iResult=-ENOSYS;
 127     }
 128   } else {
 129     iResult=-EINVAL;
 130   }
 131
 132   return iResult;
 133 }
 134
 135 int AliHLTLogging::InitAliLogFunc(AliHLTComponentHandler* pHandler)
 136 {
 137   // see header file for class documentation
 138   int iResult=0;
 139   if (pHandler) {
 140     // set temporary loglevel of component handler
 141     AliHLTComponentLogSeverity loglevel=pHandler->GetLocalLoggingLevel();
 142     pHandler->SetLocalLoggingLevel(kHLTLogError);
 143
 144     // load library containing AliRoot dependencies and initialization handler
 145     pHandler->LoadLibrary(ALILOG_WRAPPER_LIBRARY, 0/* do not activate agents */);
 146
 147     // restore loglevel
 148     pHandler->SetLocalLoggingLevel(loglevel);
 149
 150     // find the symbol
 151     fgAliLoggingFunc=(AliHLTLogging::AliHLTDynamicMessage)pHandler->FindSymbol(ALILOG_WRAPPER_LIBRARY, "AliDynamicMessage");
 152     if (fgAliLoggingFunc==NULL) {
 153       Message(NULL, kHLTLogError, "AliHLTLogging::InitAliLogFunc", "init logging",
 154               "symbol lookup failure: can not find AliDynamicMessage, switching to HLT logging system");
 155       iResult=-ENOSYS;
 156     }
 157   } else {
 158     iResult=-EINVAL;
 159   }
 160
 161   return iResult;
 162 }
 163
 164 int AliHLTLogging::Message(void *param, AliHLTComponentLogSeverity severity,
 165                            const char* origin, const char* keyword,
 166                            const char* message)
 167 {
 168   // see header file for class documentation
 169   int iResult=0;
 170   if (param==NULL) {
 171     // this is currently just to get rid of the warning "unused parameter"
 172   }
 173
 174   const char* strSeverity="";
 175   switch (severity) {
 176   case kHLTLogBenchmark:
 177     strSeverity="benchmark";
 178     break;
 179   case kHLTLogDebug:
 180     strSeverity="debug";
 181     break;
 182   case kHLTLogInfo:
 183     strSeverity="info";
 184     break;
 185   case kHLTLogWarning:
 186     strSeverity="warning";
 187     break;
 188   case kHLTLogError:
 189     strSeverity="error";
 190     break;
 191   case kHLTLogFatal:
 192     strSeverity="fatal";
 193     break;
 194   case kHLTLogImportant:
 195     strSeverity="notify";
 196     break;
 197   default:
 198     break;
 199   }
 200   TString out="HLT Log ";
 201   out+=strSeverity;
 202   if (origin && origin[0]!=0) {out+=": <"; out+=origin; out+="> ";}
 203   out+=" "; out+=message;
 204   if (keyword!=NULL && strcmp(keyword, HLT_DEFAULT_LOG_KEYWORD)!=0) {
 205     out+=" ("; out+=keyword; out +=")";
 206   }
 207   cout << out.Data() << endl;
 208   return iResult;
 209 }
 210
 211 #if 0
 212 int AliHLTLogging::AliMessage(AliHLTComponentLogSeverity severity,
 213                               const char* originClass, const char* originFunc,
 214                               const char* file, int line, const char* message)
 215 {
 216   // see header file for class documentation
 217
 218   switch (severity) {
 219   case kHLTLogBenchmark:
 220     AliLog::Message(AliLog::kInfo, message, "HLT", originClass, originFunc, file, line);
 221     break;
 222   case kHLTLogDebug:
 223     AliLog::Message(AliLog::kDebug, message, "HLT", originClass, originFunc, file, line);
 224     break;
 225   case kHLTLogInfo:
 226     AliLog::Message(AliLog::kInfo, message, "HLT", originClass, originFunc, file, line);
 227     break;
 228   case kHLTLogWarning:
 229     AliLog::Message(AliLog::kWarning, message, "HLT", originClass, originFunc, file, line);
 230     break;
 231   case kHLTLogError:
 232     AliLog::Message(AliLog::kError, message, "HLT", originClass, originFunc, file, line);
 233     break;
 234   case kHLTLogFatal:
 235     AliLog::Message(AliLog::kWarning, message, "HLT", originClass, originFunc, file, line);
 236     break;
 237   default:
 238     break;
 239   }
 240   return 0;
 241 }
 242 #endif
 243
 244 const char* AliHLTLogging::BuildLogString(const char *format, va_list &ap, bool bAppend)
 245 {
 246   // see header file for class documentation
 247
 248   int iResult=0;
 249 #ifdef R__VA_COPY
 250   va_list bap;
 251   R__VA_COPY(bap, ap);
 252 #endif //R__VA_COPY
 253
 254   // take the first argument from the list as format string if no
 255   // format was given
 256   const char* fmt = format;
 257   if (fmt==NULL) fmt=va_arg(ap, const char*);
 258
 259   unsigned int iOffset=0;
 260   if (bAppend) {
 261     iOffset=strlen(fgAliHLTLoggingTarget.GetArray());
 262   } else {
 263     fgAliHLTLoggingTarget[0]=0;
 264   }
 265   while (fmt!=NULL) {
 266     iResult=vsnprintf(fgAliHLTLoggingTarget.GetArray()+iOffset, fgAliHLTLoggingTarget.GetSize()-iOffset, fmt, ap);
 267     if (iResult==-1)
 268       // for compatibility with older version of vsnprintf
 269       iResult=fgAliHLTLoggingTarget.GetSize()*2;
 270     else
 271       iResult+=iOffset;
 272
 273     if (iResult<fgAliHLTLoggingTarget.GetSize())
 274       // everything in the limit
 275       break;
 276
 277     // terminate if buffer is already at the limit
 278     if (fgAliHLTLoggingTarget.GetSize()>=fgkALIHLTLOGGINGMAXBUFFERSIZE)
 279     {
 280       fgAliHLTLoggingTarget[fgAliHLTLoggingTarget.GetSize()-1]=0;
 281       break;
 282     }
 283
 284     // check limitation and grow the buffer
 285     if (iResult>fgkALIHLTLOGGINGMAXBUFFERSIZE) iResult=fgkALIHLTLOGGINGMAXBUFFERSIZE;
 286     fgAliHLTLoggingTarget.Set(iResult+1);
 287
 288     // copy the original list and skip the first argument if this was the format string
 289 #ifdef R__VA_COPY
 290     va_end(ap);
 291     R__VA_COPY(ap, bap);
 292 #else
 293     fgAliHLTLoggingTarget[fgAliHLTLoggingTarget.GetSize()-1]=0;
 294     break;
 295 #endif //R__VA_COPY
 296     if (format==NULL) va_arg(ap, const char*);
 297   }
 298 #ifdef R__VA_COPY
 299   va_end(bap);
 300 #endif //R__VA_COPY
 301
 302   return fgAliHLTLoggingTarget.GetArray();
 303 }
 304
 305 const char* AliHLTLogging::SetLogString(const void* p, const char* pfmt, const char *format, ...)
 306 {
 307   // see header file for class documentation
 308   if (!p || !pfmt) return NULL;
 309   TString formatstr=format;
 310   TString pstr;
 311 #ifdef __DEBUG
 312   pstr.Form(pfmt, p);
 313 #endif
 314   formatstr.ReplaceAll("_pfmt_", pstr);
 315   va_list args;
 316   va_start(args, format);
 317
 318   const char* message=BuildLogString(formatstr.Data(), args);
 319   va_end(args);
 320
 321   return message;
 322 }
 323
 324 int AliHLTLogging::Logging(AliHLTComponentLogSeverity severity,
 325                            const char* origin, const char* keyword,
 326                            const char* format, ... )
 327 {
 328   // see header file for class documentation
 329   int iResult=CheckFilter(severity);
 330   if (iResult>0) {
 331     va_list args;
 332     va_start(args, format);
 333     if (fgLoggingFunc) {
 334       iResult = (*fgLoggingFunc)(NULL/*fParam*/, severity, origin, keyword, AliHLTLogging::BuildLogString(format, args ));
 335     } else {
 336       if (fgUseAliLog!=0 && fgAliLoggingFunc!=NULL)
 337         iResult=(*fgAliLoggingFunc)(severity, NULL, origin, NULL, 0, AliHLTLogging::BuildLogString(format, args ));
 338       else
 339         iResult=Message(NULL/*fParam*/, severity, origin, keyword, AliHLTLogging::BuildLogString(format, args ));
 340     }
 341     va_end(args);
 342   }
 343   return iResult;
 344 }
 345
 346 int AliHLTLogging::LoggingVarargs(AliHLTComponentLogSeverity severity,
 347                                   const char* originClass, const char* originFunc,
 348                                   const char* file, int line,  ... ) const
 349 {
 350   // see header file for class documentation
 351   int iResult=0;
 352
 353   va_list args;
 354   va_start(args, line);
 355
 356   iResult=SendMessage(severity, originClass, originFunc, file, line, AliHLTLogging::BuildLogString(NULL, args ));
 357   va_end(args);
 358
 359   return iResult;
 360 }
 361
 362 int AliHLTLogging::SendMessage(AliHLTComponentLogSeverity severity,
 363                                const char* originClass, const char* originFunc,
 364                                const char* file, int line,
 365                                const char* message) const
 366 {
 367   // see header file for class documentation
 368   int iResult=0;
 369   const char* separator="";
 370   TString origin;
 371   if (originClass) {
 372     origin+=originClass;
 373     separator="::";
 374   }
 375   if (originFunc) {
 376     origin+=separator;
 377     origin+=originFunc;
 378   }
 379
 380   if (fgLoggingFunc) {
 381     iResult=(*fgLoggingFunc)(NULL/*fParam*/, severity, origin.Data(), GetKeyword(), message);
 382   } else {
 383     if (fgUseAliLog!=0 && fgAliLoggingFunc!=NULL)
 384       iResult=(*fgAliLoggingFunc)(severity, originClass, originFunc, file, line, message);
 385     else
 386       iResult=Message(NULL/*fParam*/, severity, origin.Data(), GetKeyword(), message);
 387   }
 388   return iResult;
 389 }
 390
 391 int AliHLTLogging::CheckFilter(AliHLTComponentLogSeverity severity) const
 392 {
 393   // see header file for class documentation
 394
 395   int iResult=severity==kHLTLogNone || ((severity&fgGlobalLogFilter)>0 && (severity&fLocalLogFilter)>0);
 396   return iResult;
 397 }
 398
 399 void AliHLTLogging::SetGlobalLoggingLevel(AliHLTComponentLogSeverity level)
 400 {
 401   // see header file for class documentation
 402
 403   fgGlobalLogFilter=level;
 404 }
 405
 406 AliHLTComponentLogSeverity AliHLTLogging::GetGlobalLoggingLevel()
 407 {
 408   // see header file for class documentation
 409
 410   return fgGlobalLogFilter;
 411 }
 412
 413 void AliHLTLogging::SetLocalLoggingLevel(AliHLTComponentLogSeverity level)
 414 {
 415   // see header file for class documentation
 416
 417   fLocalLogFilter=level;
 418 }
 419
 420
 421 AliHLTComponentLogSeverity AliHLTLogging::GetLocalLoggingLevel()
 422 {
 423   // see header file for class documentation
 424
 425   return fLocalLogFilter;
 426 }
 427
 428 void AliHLTLogging::SetLocalLoggingDefault(AliHLTComponentLogSeverity level)
 429 {
 430   // see header file for class documentation
 431   fgLocalLogDefault=level;
 432 }
 433
 434 int AliHLTLogging::CheckGroup(const char* /*originClass*/) const
 435 {
 436   // see header file for class documentation
 437
 438   return 1;
 439 }
 440
 441 int AliHLTLogging::SetBlackList(const char* classnames)
 442 {
 443   // see header file for class documentation
 444
 445   if (classnames)
 446     fgBlackList=classnames;
 447   return 0;
 448 }
 449
 450 int AliHLTLogging::SetWhiteList(const char* classnames)
 451 {
 452   // see header file for class documentation
 453
 454   if (classnames)
 455     fgWhiteList=classnames;
 456   return 0;
 457 }