4 #ifndef ALIHLTLOGGING_H
5 #define ALIHLTLOGGING_H
6 ///* This file is property of and copyright by the *
7 ///* ALICE Experiment at CERN, All rights reserved. *
8 ///* See cxx source for full Copyright notice */
10 /// @file AliHLTLogging.h
11 /// @author Matthias Richter, Timm Steinbeck
13 /// @brief HLT module logging primitives.
16 #include "AliHLTDataTypes.h"
17 #include "AliHLTStdIncludes.h"
22 class AliHLTComponentHandler;
23 //#define LOG_PREFIX "" // logging prefix, for later extensions
25 #define ALILOG_WRAPPER_LIBRARY "libHLTrec.so"
27 /* the logging macros can be used inside methods of classes which inherit from
31 #if defined(__GNUC__) || defined(__ICC) || defined(__ECC) || defined(__APPLE__)
32 #define FUNCTIONNAME() __FUNCTION__
34 #define FUNCTIONNAME() "???"
37 #ifndef ALIHLTLOGGINGVARIADICFREE_H
38 // HLTMessage is not filtered
39 #define HLTMessage( ... ) LoggingVarargs(kHLTLogNone, NULL , NULL , __FILE__ , __LINE__ , __VA_ARGS__ )
41 // the following macros are filtered by the Global and Local Log Filter
42 #define HLTLog( level, ... ) if (CheckFilter(level)) LoggingVarargs(level, Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , __VA_ARGS__ )
43 #define HLTBenchmark( ... ) LoggingVarargs(kHLTLogBenchmark, Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , __VA_ARGS__ )
45 #define HLTDebug( ... ) if (CheckFilter(kHLTLogDebug) && CheckGroup(Class_Name())) LoggingVarargs(kHLTLogDebug, Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , __VA_ARGS__ )
47 #define HLTDebug( ... )
49 #define HLTInfo( ... ) if (CheckFilter(kHLTLogInfo)) LoggingVarargs(kHLTLogInfo, Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , __VA_ARGS__ )
50 #define HLTWarning( ... ) if (CheckFilter(kHLTLogWarning)) LoggingVarargs(kHLTLogWarning, Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , __VA_ARGS__ )
51 #define HLTError( ... ) if (CheckFilter(kHLTLogError)) LoggingVarargs(kHLTLogError, Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , __VA_ARGS__ )
52 #define HLTFatal( ... ) if (CheckFilter(kHLTLogFatal)) LoggingVarargs(kHLTLogFatal, Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , __VA_ARGS__ )
53 #define HLTImportant( ... ) if (CheckFilter(kHLTLogImportant))LoggingVarargs(kHLTLogImportant,Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , __VA_ARGS__ )
55 // the same macros are defined variadic free, in that case the message must be complete
56 // include AliHLTLoggingVariadicFree.h
57 #else //ALIHLTLOGGINGVARIADICFREE_H
58 #define HLTMessage( message ) LoggingVarargs(kHLTLogNone, NULL , NULL , __FILE__ , __LINE__ , message )
59 #define HLTLog( level, message) if (CheckFilter(level)) LoggingVarargs(level, Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , message )
60 #define HLTBenchmark( message ) LoggingVarargs(kHLTLogBenchmark, Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , message )
62 #define HLTDebug( message ) if (CheckFilter(kHLTLogDebug) && CheckGroup(Class_Name())) LoggingVarargs(kHLTLogDebug, Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , message )
64 #define HLTDebug( message )
66 #define HLTInfo( message ) if (CheckFilter(kHLTLogInfo)) LoggingVarargs(kHLTLogInfo, Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , message )
67 #define HLTWarning( message ) if (CheckFilter(kHLTLogWarning)) LoggingVarargs(kHLTLogWarning, Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , message )
68 #define HLTError( message ) if (CheckFilter(kHLTLogError)) LoggingVarargs(kHLTLogError, Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , message )
69 #define HLTFatal( message ) if (CheckFilter(kHLTLogFatal)) LoggingVarargs(kHLTLogFatal, Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , message )
70 #define HLTImportant( message ) if (CheckFilter(kHLTLogImportant))LoggingVarargs(kHLTLogImportant,Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , message )
71 #endif //ALIHLTLOGGINGVARIADICFREE_H
73 // helper macro to set the keyword
74 #define HLTLogKeyword(a) AliHLTKeyword hltlogTmpkey(this, a)
76 #define HLT_DEFAULT_LOG_KEYWORD "no key"
79 * @class AliHLTLogging
80 * Basic logging class. All classes inherit the besic HLT logging functionality.
81 * Logging levels are controlled by a global logging filter and a local logging
84 * @section alihlt_logging_levels Logging Levels
85 * Logging levels are switched by a bit pattern, AliHLTComponentLogSeverity {
86 * - ::kHLTLogNone no logging (0)
87 * - ::kHLTLogBenchmark benchmark messages (0x1)
88 * - ::kHLTLogDebug debug messages (0x2)
89 * - ::kHLTLogInfo info messages (0x4)
90 * - ::kHLTLogWarning warning messages (0x8)
91 * - ::kHLTLogError error messages (0x10)
92 * - ::kHLTLogFatal fatal error messages (0x20)
93 * - ::kHLTLogImportant few important messages not to be filtered out (0x40)
94 * - ::kHLTLogAll special value to enable all messages (0x7f)
95 * - ::kHLTLogDefault the default logging level: Warning, Error, Fatal, Important (0x79)
97 * @section alihlt_logging_filter Logging Filters
98 * The class provides a global and a local logging filter, the AND beween both
99 * defines whether a message is printed or not.
101 * The global filter is by default set to ::kHLTLogAll. Please note that AliHLTSystem
102 * changes the global logging level to ::kHLTLogDefault. The global filter can be
103 * adjusted by means of SetGlobalLoggingLevel().
105 * The local filter is set to ::kHLTLogAll and can be adjusted by
106 * SetLocalLoggingLevel(). The default can be changed for all objects by
107 * SetLocalLoggingDefault(). Please note that a change of the default level only
108 * applies to objects generated after the change of the default.
110 * @section alihlt_logging_external Redirection
111 * - external logging function
114 * @section alihlt_logging_aliroot AliRoot Redirection
115 * - switching of redirection
116 * - logging options in AliSimulation/AliReconstruction
118 * @ingroup alihlt_component
120 class AliHLTLogging {
123 AliHLTLogging(const AliHLTLogging&);
124 AliHLTLogging& operator=(const AliHLTLogging&);
125 virtual ~AliHLTLogging();
127 /** set the default key word
128 * the keyword is intended to simplify the use of logging macros
130 void SetDefaultKeyword(const char* keyword) { fpDefaultKeyword=keyword; }
133 * Set a temporary keyword
134 * Keywords need to be static const strings, the class handles only
135 * pointers and assumes the strings to be persistent.
136 * returns the old key value
138 const char* SetKeyword(const char* keyword)
140 const char* currentKeyword=fpCurrentKeyword;
141 fpCurrentKeyword=keyword;
142 return currentKeyword;
146 * Get the current keyword
148 const char* GetKeyword() const
150 if (fpCurrentKeyword) return fpCurrentKeyword;
151 else if (fpDefaultKeyword) return fpDefaultKeyword;
152 return HLT_DEFAULT_LOG_KEYWORD;
156 * Init the AliLogging class for use from external package.
157 * This initializes the logging callback. <br>
158 * Only deployed by external users of the C wrapper interface, not used
159 * when running in AliRoot
161 static int Init(AliHLTfctLogging pFun);
164 * Init the message trap in AliLog.
165 * This initializes the AliLog trap, the AliLog class is the logging
166 * mechanism of AliRoot. The trap can fetch log messages written to
167 * AliLog, components and detector algorithms can use the AliLog
168 * mechanism to be as close as possible to Offline habits. <br>
169 * Only used with external users of the C wrapper interface, not used
170 * when running in AliRoot
172 static int InitAliLogTrap(AliHLTComponentHandler* pHandler);
175 * Init the AliRoot logging function.
176 * All log messages are redirected to AliLog when running in AliRoot.
177 * Note: when running in PubSub, AliLog messages are redirected to PubSub,
178 * see AliHLTLogging::InitAliLogTrap
180 static int InitAliLogFunc(AliHLTComponentHandler* pHandler);
183 * Genaral logging function
185 int Logging( AliHLTComponentLogSeverity severity, const char* origin, const char* keyword, const char* message, ... );
188 * Logging function with two origin parameters, used by the log macros
190 virtual int LoggingVarargs(AliHLTComponentLogSeverity severity,
191 const char* originClass, const char* originFunc,
192 const char* file, int line, ... ) const;
195 * Send formatted string to the different channels
197 int SendMessage(AliHLTComponentLogSeverity severity,
198 const char* originClass, const char* originFunc,
199 const char* file, int line,
200 const char* message) const;
203 * Evaluate the group of the debug message from the class name.
204 * @return 1 if message should be printed
206 int CheckGroup(const char* originClass) const;
209 * Set the black list of classes.
210 * If the white list is set, debug messages are skipped for
211 * all classes matching one of the regular expressions in the string.
213 static int SetBlackList(const char* classnames);
216 * Set the white list of classes.
217 * If the white list is set, debug messages are only printed for
218 * classes matching one of the regular expressions in the string.
220 static int SetWhiteList(const char* classnames);
224 * @return 1 if message should pass
226 int CheckFilter(AliHLTComponentLogSeverity severity) const;
229 * Set global logging level
230 * logging filter for all objects
232 static void SetGlobalLoggingLevel(AliHLTComponentLogSeverity level);
235 * Get global logging level
236 * logging filter for all objects
238 static AliHLTComponentLogSeverity GetGlobalLoggingLevel();
241 * Set local logging level
242 * logging filter for individual object
244 virtual void SetLocalLoggingLevel(AliHLTComponentLogSeverity level);
247 * Set local logging default
248 * Default logging filter for individual objects.
250 static void SetLocalLoggingDefault(AliHLTComponentLogSeverity level);
253 * Get default setting for local logging filter for individual objects.
255 static AliHLTComponentLogSeverity GetLocalLoggingDefault() { return fgLocalLogDefault; }
258 * Get local logging level
259 * logging filter for individual object
261 AliHLTComponentLogSeverity GetLocalLoggingLevel();
264 * Print message to stdout
266 static int Message(void * param, AliHLTComponentLogSeverity severity, const char* origin, const char* keyword, const char* message);
269 * Build the log string from format specifier and variadac arguments
270 * @param format format string of printf style
271 * @param ap opened and initialized argument list
272 * @param bAppend append to current content
273 * @return const char string with the formatted message
275 static const char* BuildLogString(const char *format, va_list &ap, bool bAppend=false);
278 * Set the log string from format specifier and from variable arguments.
279 * @param format format string of printf style
280 * @return const char string with the formatted message
282 static const char* SetLogString(const void* p, const char* pfmt, const char *format, ... );
285 * Get parameter given by the external caller.
286 * This functionality is not yet implemented. It is intended
287 * to pass the parameter pointer given to the component at
288 * initialization back to the caller.
290 virtual void* GetParameter() const {return NULL;}
293 * Switch logging through AliLog on or off
294 * @param sw 1 = logging through AliLog
296 void SwitchAliLog(int sw) {fgUseAliLog=(sw!=0);}
298 /** target stream for AliRoot logging methods */
299 static ostringstream fgLogstr; //! transient
302 * The message function for dynamic use.
303 * In order to avoid dependencies on AliRoot libraries, libHLTbase loads
304 * the library dynamically and looks for the symbol.
306 typedef int (*AliHLTDynamicMessage)(AliHLTComponentLogSeverity severity,
307 const char* originClass,
308 const char* originFunc,
309 const char* file, int line,
310 const char* message);
313 * The init function of the message callback for dynamic use.
314 * In order to avoid dependencies on AliRoot libraries, libHLTbase loads
315 * the library dynamically and looks for the symbol.
317 typedef int (*InitAliDynamicMessageCallback)();
320 /** the AliRoot logging function */
321 static AliHLTDynamicMessage fgAliLoggingFunc; //! transient
324 /** the global logging filter */
325 static AliHLTComponentLogSeverity fgGlobalLogFilter; // see above
326 /** the local logging filter for one class */
327 AliHLTComponentLogSeverity fLocalLogFilter; // see above
328 /** the global logging filter */
329 static AliHLTComponentLogSeverity fgLocalLogDefault; // see above
330 /** logging callback from the framework */
331 static AliHLTfctLogging fgLoggingFunc; // see above
332 /** default keyword */
333 const char* fpDefaultKeyword; //! transient
334 /** current keyword */
335 const char* fpCurrentKeyword; //! transient
336 /** switch for logging through AliLog, default on */
337 static int fgUseAliLog; // see above
339 * The global logging buffer.
340 * The buffer is created with an initial size and grown dynamically on
343 static TArrayC fgAliHLTLoggingTarget; //! transient
345 /** the maximum size of the buffer */
346 static const int fgkALIHLTLOGGINGMAXBUFFERSIZE; //! transient
348 /** groups of classes not to print debug messages */
349 static TString fgBlackList; //! transient
351 /** groups of classes not to print debug messages */
352 static TString fgWhiteList; //! transient
354 ClassDef(AliHLTLogging, 0)
357 /* the class AliHLTKeyword is a simple helper class used by the HLTLogKeyword macro
358 * HLTLogKeyword("a keyword") creates an object of AliHLTKeyword which sets the keyword for the logging class
359 * the object is destroyed automatically when the current scope is left and so the keyword is set
360 * to the original value. Please note that all keywords need to be static strings, only pointyers
361 * are handled and the strings required to ber persistent.
363 class AliHLTKeyword {
372 AliHLTKeyword(const AliHLTLogging* parent, const char* keyword)
374 fpParent(const_cast<AliHLTLogging*>(parent)),
377 // the const cast is on purpose in order to be allowed to use
378 // HLTLogKeyword from const member functions
380 fpOriginal=fpParent->SetKeyword(keyword);
387 fpParent->SetKeyword(fpOriginal);
392 /// copy constructor prohibited
393 AliHLTKeyword(const AliHLTKeyword& kw);
394 /// assignment operator prohibited
395 AliHLTKeyword& operator=(const AliHLTKeyword& kw);
397 AliHLTLogging* fpParent; //! transient
398 const char* fpOriginal; //! transient