Line data Source code
1 : //-*- Mode: C++ -*-
2 : // $Id$
3 :
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 */
9 :
10 : /// @file AliHLTLogging.h
11 : /// @author Matthias Richter, Timm Steinbeck
12 : /// @date
13 : /// @brief HLT module logging primitives.
14 : ///
15 :
16 : #include "AliHLTDataTypes.h"
17 : #include "AliHLTStdIncludes.h"
18 : #include "TString.h"
19 : #include "TObject.h"
20 : #include "TArrayC.h"
21 :
22 : class AliHLTComponentHandler;
23 : //#define LOG_PREFIX "" // logging prefix, for later extensions
24 :
25 : #define ALILOG_WRAPPER_LIBRARY "libHLTrec.so"
26 :
27 : /* the logging macros can be used inside methods of classes which inherit from
28 : * AliHLTLogging
29 : */
30 : // function name
31 : #if defined(__GNUC__) || defined(__ICC) || defined(__ECC) || defined(__APPLE__)
32 : #define FUNCTIONNAME() __FUNCTION__
33 : #else
34 : #define FUNCTIONNAME() "???"
35 : #endif
36 :
37 : #ifndef ALIHLTLOGGINGVARIADICFREE_H
38 : // HLTMessage is not filtered
39 : #define HLTMessage( ... ) LoggingVarargs(kHLTLogNone, NULL , NULL , __FILE__ , __LINE__ , __VA_ARGS__ )
40 :
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__ )
44 : #ifdef __DEBUG
45 : #define HLTDebug( ... ) if (CheckFilter(kHLTLogDebug) && CheckGroup(Class_Name())) LoggingVarargs(kHLTLogDebug, Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , __VA_ARGS__ )
46 : #else
47 : #define HLTDebug( ... )
48 : #endif
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__ )
54 :
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 )
61 : #ifdef __DEBUG
62 : #define HLTDebug( message ) if (CheckFilter(kHLTLogDebug) && CheckGroup(Class_Name())) LoggingVarargs(kHLTLogDebug, Class_Name() , FUNCTIONNAME() , __FILE__ , __LINE__ , message )
63 : #else
64 : #define HLTDebug( message )
65 : #endif
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
72 :
73 : // helper macro to set the keyword
74 : #define HLTLogKeyword(a) AliHLTKeyword hltlogTmpkey(this, a)
75 :
76 : #define HLT_DEFAULT_LOG_KEYWORD "no key"
77 :
78 : /**
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
82 : * filter.
83 : *
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)
96 : *
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.
100 : *
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().
104 : *
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.
109 : *
110 : * @section alihlt_logging_external Redirection
111 : * - external logging function
112 : * - keyword
113 : *
114 : * @section alihlt_logging_aliroot AliRoot Redirection
115 : * - switching of redirection
116 : * - logging options in AliSimulation/AliReconstruction
117 : *
118 : * @ingroup alihlt_component
119 : */
120 : class AliHLTLogging {
121 : public:
122 : AliHLTLogging();
123 : AliHLTLogging(const AliHLTLogging&);
124 : AliHLTLogging& operator=(const AliHLTLogging&);
125 : virtual ~AliHLTLogging();
126 :
127 : /** set the default key word
128 : * the keyword is intended to simplify the use of logging macros
129 : */
130 0 : void SetDefaultKeyword(const char* keyword) { fpDefaultKeyword=keyword; }
131 :
132 : /**
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
137 : */
138 : const char* SetKeyword(const char* keyword)
139 : {
140 0 : const char* currentKeyword=fpCurrentKeyword;
141 0 : fpCurrentKeyword=keyword;
142 0 : return currentKeyword;
143 : }
144 :
145 : /**
146 : * Get the current keyword
147 : */
148 : const char* GetKeyword() const
149 : {
150 0 : if (fpCurrentKeyword) return fpCurrentKeyword;
151 0 : else if (fpDefaultKeyword) return fpDefaultKeyword;
152 0 : return HLT_DEFAULT_LOG_KEYWORD;
153 0 : }
154 :
155 : /**
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
160 : */
161 : static int Init(AliHLTfctLogging pFun);
162 :
163 : /**
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
171 : */
172 : static int InitAliLogTrap(AliHLTComponentHandler* pHandler);
173 :
174 : /**
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
179 : */
180 : static int InitAliLogFunc(AliHLTComponentHandler* pHandler);
181 :
182 : /**
183 : * Genaral logging function
184 : */
185 : int Logging( AliHLTComponentLogSeverity severity, const char* origin, const char* keyword, const char* message, ... );
186 :
187 : /**
188 : * Logging function with two origin parameters, used by the log macros
189 : */
190 : virtual int LoggingVarargs(AliHLTComponentLogSeverity severity,
191 : const char* originClass, const char* originFunc,
192 : const char* file, int line, ... ) const;
193 :
194 : /**
195 : * Send formatted string to the different channels
196 : */
197 : int SendMessage(AliHLTComponentLogSeverity severity,
198 : const char* originClass, const char* originFunc,
199 : const char* file, int line,
200 : const char* message) const;
201 :
202 : /**
203 : * Evaluate the group of the debug message from the class name.
204 : * @return 1 if message should be printed
205 : */
206 : int CheckGroup(const char* originClass) const;
207 :
208 : /**
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.
212 : */
213 : static int SetBlackList(const char* classnames);
214 :
215 : /**
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.
219 : */
220 : static int SetWhiteList(const char* classnames);
221 :
222 : /**
223 : * Apply filter
224 : * @return 1 if message should pass
225 : */
226 : int CheckFilter(AliHLTComponentLogSeverity severity) const;
227 :
228 : /**
229 : * Set global logging level
230 : * logging filter for all objects
231 : */
232 : static void SetGlobalLoggingLevel(AliHLTComponentLogSeverity level);
233 :
234 : /**
235 : * Get global logging level
236 : * logging filter for all objects
237 : */
238 : static AliHLTComponentLogSeverity GetGlobalLoggingLevel();
239 :
240 : /**
241 : * Set local logging level
242 : * logging filter for individual object
243 : */
244 : virtual void SetLocalLoggingLevel(AliHLTComponentLogSeverity level);
245 :
246 : /**
247 : * Set local logging default
248 : * Default logging filter for individual objects.
249 : */
250 : static void SetLocalLoggingDefault(AliHLTComponentLogSeverity level);
251 :
252 : /**
253 : * Get default setting for local logging filter for individual objects.
254 : */
255 0 : static AliHLTComponentLogSeverity GetLocalLoggingDefault() { return fgLocalLogDefault; }
256 :
257 : /**
258 : * Get local logging level
259 : * logging filter for individual object
260 : */
261 : AliHLTComponentLogSeverity GetLocalLoggingLevel();
262 :
263 : /**
264 : * Print message to stdout
265 : */
266 : static int Message(void * param, AliHLTComponentLogSeverity severity, const char* origin, const char* keyword, const char* message);
267 :
268 : /**
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
274 : */
275 : static const char* BuildLogString(const char *format, va_list &ap, bool bAppend=false);
276 :
277 : /**
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
281 : */
282 : static const char* SetLogString(const void* p, const char* pfmt, const char *format, ... );
283 :
284 : /**
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.
289 : */
290 0 : virtual void* GetParameter() const {return NULL;}
291 :
292 : /**
293 : * Switch logging through AliLog on or off
294 : * @param sw 1 = logging through AliLog
295 : */
296 0 : void SwitchAliLog(int sw) {fgUseAliLog=(sw!=0);}
297 :
298 : /** target stream for AliRoot logging methods */
299 : static ostringstream fgLogstr; //! transient
300 :
301 : /**
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.
305 : */
306 : typedef int (*AliHLTDynamicMessage)(AliHLTComponentLogSeverity severity,
307 : const char* originClass,
308 : const char* originFunc,
309 : const char* file, int line,
310 : const char* message);
311 :
312 : /**
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.
316 : */
317 : typedef int (*InitAliDynamicMessageCallback)();
318 :
319 : protected:
320 : /** the AliRoot logging function */
321 : static AliHLTDynamicMessage fgAliLoggingFunc; //! transient
322 :
323 : private:
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
338 : /**
339 : * The global logging buffer.
340 : * The buffer is created with an initial size and grown dynamically on
341 : * demand.
342 : */
343 : static TArrayC fgAliHLTLoggingTarget; //! transient
344 :
345 : /** the maximum size of the buffer */
346 : static const int fgkALIHLTLOGGINGMAXBUFFERSIZE; //! transient
347 :
348 : /** groups of classes not to print debug messages */
349 : static TString fgBlackList; //! transient
350 :
351 : /** groups of classes not to print debug messages */
352 : static TString fgWhiteList; //! transient
353 :
354 150 : ClassDef(AliHLTLogging, 0)
355 : };
356 :
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.
362 : */
363 : class AliHLTKeyword {
364 : public:
365 : AliHLTKeyword()
366 : :
367 : fpParent(NULL),
368 : fpOriginal(NULL)
369 : {
370 : }
371 :
372 : AliHLTKeyword(const AliHLTLogging* parent, const char* keyword)
373 : :
374 0 : fpParent(const_cast<AliHLTLogging*>(parent)),
375 0 : fpOriginal(NULL)
376 0 : {
377 : // the const cast is on purpose in order to be allowed to use
378 : // HLTLogKeyword from const member functions
379 0 : if (fpParent) {
380 0 : fpOriginal=fpParent->SetKeyword(keyword);
381 0 : }
382 0 : }
383 :
384 : ~AliHLTKeyword()
385 0 : {
386 0 : if (fpParent) {
387 0 : fpParent->SetKeyword(fpOriginal);
388 0 : }
389 0 : }
390 :
391 : private:
392 : /// copy constructor prohibited
393 : AliHLTKeyword(const AliHLTKeyword& kw);
394 : /// assignment operator prohibited
395 : AliHLTKeyword& operator=(const AliHLTKeyword& kw);
396 :
397 : AliHLTLogging* fpParent; //! transient
398 : const char* fpOriginal; //! transient
399 : };
400 : #endif
401 :
|
