HLT/BASE/AliHLTLogging.cxx

   1 // @(#) $Id$
   2
   3 /**************************************************************************
   4  * This file is property of and copyright by the ALICE HLT Project        *
   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 #if __GNUC__>= 3
  26 using namespace std;
  27 #endif
  28
  29 #include "AliHLTStdIncludes.h"
  30 #include "AliHLTLogging.h"
  31 #include "AliHLTComponentHandler.h"
  32 #include "TString.h"
  33 #include "Varargs.h"
  34 #include <string>
  35 #include <sstream>
  36 #include <iostream>
  37
  38 /** ROOT macro for the implementation of ROOT specific class methods */
  39 ClassImp(AliHLTLogging);
  40
  41 AliHLTLogging::AliHLTLogging()
  42   :
  43   //fLocalLogFilter(kHLTLogDefault),
  44   fLocalLogFilter(kHLTLogAll),
  45   fpDefaultKeyword(NULL),
  46   fpCurrentKeyword(NULL)
  47 {
  48   // see header file for class documentation
  49   // or
  50   // refer to README to build package
  51   // or
  52   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  53 }
  54
  55 AliHLTLogging::AliHLTLogging(const AliHLTLogging&)
  56   :
  57   fLocalLogFilter(kHLTLogAll),
  58   fpDefaultKeyword(NULL),
  59   fpCurrentKeyword(NULL)
  60 {
  61   // see header file for class documentation
  62   HLTFatal("copy constructor untested");
  63 }
  64
  65 AliHLTLogging& AliHLTLogging::operator=(const AliHLTLogging&)
  66 {
  67   // see header file for class documentation
  68   HLTFatal("assignment operator untested");
  69   return *this;
  70 }
  71
  72 ostringstream AliHLTLogging::fgLogstr;
  73 AliHLTComponentLogSeverity AliHLTLogging::fgGlobalLogFilter=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 lookp 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   default:
 195     break;
 196   }
 197   TString out="HLT Log ";
 198   out+=strSeverity;
 199   if (origin && origin[0]!=0) {out+=": <"; out+=origin; out+="> ";}
 200   out+=" "; out+=message;
 201   if (keyword!=NULL && strcmp(keyword, HLT_DEFAULT_LOG_KEYWORD)!=0) {
 202     out+=" ("; out+=keyword; out +=")";
 203   }
 204   cout << out.Data() << endl;
 205   return iResult;
 206 }
 207
 208 #if 0
 209 int AliHLTLogging::AliMessage(AliHLTComponentLogSeverity severity,
 210                               const char* originClass, const char* originFunc,
 211                               const char* file, int line, const char* message)
 212 {
 213   // see header file for class documentation
 214
 215   switch (severity) {
 216   case kHLTLogBenchmark:
 217     AliLog::Message(AliLog::kInfo, message, "HLT", originClass, originFunc, file, line);
 218     break;
 219   case kHLTLogDebug:
 220     AliLog::Message(AliLog::kDebug, message, "HLT", originClass, originFunc, file, line);
 221     break;
 222   case kHLTLogInfo:
 223     AliLog::Message(AliLog::kInfo, message, "HLT", originClass, originFunc, file, line);
 224     break;
 225   case kHLTLogWarning:
 226     AliLog::Message(AliLog::kWarning, message, "HLT", originClass, originFunc, file, line);
 227     break;
 228   case kHLTLogError:
 229     AliLog::Message(AliLog::kError, message, "HLT", originClass, originFunc, file, line);
 230     break;
 231   case kHLTLogFatal:
 232     AliLog::Message(AliLog::kWarning, message, "HLT", originClass, originFunc, file, line);
 233     break;
 234   default:
 235     break;
 236   }
 237   return 0;
 238 }
 239 #endif
 240
 241 const char* AliHLTLogging::BuildLogString(const char *format, va_list ap)
 242 {
 243   // see header file for class documentation
 244
 245   int iResult=0;
 246 #ifdef R__VA_COPY
 247   va_list bap;
 248   R__VA_COPY(bap, ap);
 249 #endif //R__VA_COPY
 250
 251   // take the first argument from the list as format string if no
 252   // format was given
 253   const char* fmt = format;
 254   if (fmt==NULL) fmt=va_arg(ap, const char*);
 255
 256   fgAliHLTLoggingTarget[0]=0;
 257   while (fmt!=NULL) {
 258     iResult=vsnprintf(fgAliHLTLoggingTarget.GetArray(), fgAliHLTLoggingTarget.GetSize(), fmt, ap);
 259     if (iResult==-1)
 260       // for compatibility with older version of vsnprintf
 261       iResult=fgAliHLTLoggingTarget.GetSize()*2;
 262     else if (iResult<fgAliHLTLoggingTarget.GetSize())
 263       break;
 264
 265     // terminate if buffer is already at the limit
 266     if (fgAliHLTLoggingTarget.GetSize()>=fgkALIHLTLOGGINGMAXBUFFERSIZE)
 267     {
 268       fgAliHLTLoggingTarget[fgAliHLTLoggingTarget.GetSize()-1]=0;
 269       break;
 270     }
 271
 272     // check limitation and grow the buffer
 273     if (iResult>fgkALIHLTLOGGINGMAXBUFFERSIZE) iResult=fgkALIHLTLOGGINGMAXBUFFERSIZE;
 274     fgAliHLTLoggingTarget.Set(iResult+1);
 275
 276     // copy the original list and skip the first argument if this was the format string
 277 #ifdef R__VA_COPY
 278     va_end(ap);
 279     R__VA_COPY(ap, bap);
 280 #else
 281     fgAliHLTLoggingTarget[fgAliHLTLoggingTarget.GetSize()-1]=0;
 282     break;
 283 #endif //R__VA_COPY
 284     if (format==NULL) va_arg(ap, const char*);
 285   }
 286 #ifdef R__VA_COPY
 287   va_end(bap);
 288 #endif //R__VA_COPY
 289
 290   return fgAliHLTLoggingTarget.GetArray();
 291 }
 292
 293 int AliHLTLogging::Logging(AliHLTComponentLogSeverity severity,
 294                            const char* origin, const char* keyword,
 295                            const char* format, ... )
 296 {
 297   // see header file for class documentation
 298   int iResult=CheckFilter(severity);
 299   if (iResult>0) {
 300     va_list args;
 301     va_start(args, format);
 302     if (fgLoggingFunc) {
 303       iResult = (*fgLoggingFunc)(NULL/*fParam*/, severity, origin, keyword, AliHLTLogging::BuildLogString(format, args ));
 304     } else {
 305       if (fgUseAliLog!=0 && fgAliLoggingFunc!=NULL)
 306         iResult=(*fgAliLoggingFunc)(severity, NULL, origin, NULL, 0, AliHLTLogging::BuildLogString(format, args ));
 307       else
 308         iResult=Message(NULL/*fParam*/, severity, origin, keyword, AliHLTLogging::BuildLogString(format, args ));
 309     }
 310     va_end(args);
 311   }
 312   return iResult;
 313 }
 314
 315 int AliHLTLogging::LoggingVarargs(AliHLTComponentLogSeverity severity,
 316                                   const char* originClass, const char* originFunc,
 317                                   const char* file, int line,  ... ) const
 318 {
 319   // see header file for class documentation
 320
 321   if (file==NULL && line==0) {
 322     // this is currently just to get rid of the warning "unused parameter"
 323   }
 324   int iResult=1; //CheckFilter(severity); // check moved to makro
 325   if (iResult>0) {
 326     const char* separator="";
 327     TString origin;
 328     if (originClass) {
 329         origin+=originClass;
 330         separator="::";
 331     }
 332     if (originFunc) {
 333         origin+=separator;
 334         origin+=originFunc;
 335     }
 336     va_list args;
 337     va_start(args, line);
 338
 339     if (fgLoggingFunc) {
 340       iResult=(*fgLoggingFunc)(NULL/*fParam*/, severity, origin.Data(), GetKeyword(), AliHLTLogging::BuildLogString(NULL, args ));
 341     } else {
 342       if (fgUseAliLog!=0 && fgAliLoggingFunc!=NULL)
 343         iResult=(*fgAliLoggingFunc)(severity, originClass, originFunc, file, line, AliHLTLogging::BuildLogString(NULL, args ));
 344       else
 345         iResult=Message(NULL/*fParam*/, severity, origin.Data(), GetKeyword(), AliHLTLogging::BuildLogString(NULL, args ));
 346     }
 347     va_end(args);
 348   }
 349   return iResult;
 350 }
 351
 352 int AliHLTLogging::CheckFilter(AliHLTComponentLogSeverity severity) const
 353 {
 354   // see header file for class documentation
 355
 356   int iResult=severity==kHLTLogNone || (severity&fgGlobalLogFilter)>0 && (severity&fLocalLogFilter)>0;
 357   return iResult;
 358 }
 359
 360 void AliHLTLogging::SetGlobalLoggingLevel(AliHLTComponentLogSeverity level)
 361 {
 362   // see header file for class documentation
 363
 364   fgGlobalLogFilter=level;
 365 }
 366
 367 AliHLTComponentLogSeverity AliHLTLogging::GetGlobalLoggingLevel()
 368 {
 369   // see header file for class documentation
 370
 371   return fgGlobalLogFilter;
 372 }
 373
 374 void AliHLTLogging::SetLocalLoggingLevel(AliHLTComponentLogSeverity level)
 375 {
 376   // see header file for class documentation
 377
 378   fLocalLogFilter=level;
 379 }
 380
 381
 382 AliHLTComponentLogSeverity AliHLTLogging::GetLocalLoggingLevel()
 383 {
 384   // see header file for class documentation
 385
 386   return fLocalLogFilter;
 387 }
 388
 389 int AliHLTLogging::CheckGroup(const char* /*originClass*/) const
 390 {
 391   // see header file for class documentation
 392
 393   return 1;
 394 }
 395
 396 int AliHLTLogging::SetBlackList(const char* classnames)
 397 {
 398   // see header file for class documentation
 399
 400   if (classnames)
 401     fgBlackList=classnames;
 402   return 0;
 403 }
 404
 405 int AliHLTLogging::SetWhiteList(const char* classnames)
 406 {
 407   // see header file for class documentation
 408
 409   if (classnames)
 410     fgWhiteList=classnames;
 411   return 0;
 412 }