|
Server : Apache/2.2.17 (Unix) mod_ssl/2.2.17 OpenSSL/0.9.8e-fips-rhel5 DAV/2 PHP/5.2.17 System : Linux localhost 2.6.18-419.el5 #1 SMP Fri Feb 24 22:47:42 UTC 2017 x86_64 User : nobody ( 99) PHP Version : 5.2.17 Disable Function : NONE Directory : /proc/21573/root/usr/lib/python2.4/site-packages/setroubleshoot/ |
Upload File : |
mò
3ÔUc @ s d Z d d d d d d d d g Z d k Z d k Z d k Z d k Z d k Z d
k Td
k Te a
h Z h Z h Z
e i Z e i a e a e a e i ƒ Z d d „ Z d „ Z d
„ Z d „ Z d „ Z d „ Z d „ Z e e d „ Z d d „ Z d „ Z! d S( sŽ
The python logging module gives us loggers and handlers, sometimes
that's a bit obscure, we rename this concepts to be more friendly:
loggers --> log_categories
handlers --> log_output
loggers are organized in a tree structure with a single root
logger. handlers may be attached to to any logger in the logger tree
(for example if you wanted to direct output from one category to a
specific place). When a handler wishes to output it walks the tree up
to the root calling each handler it finds. For simplicity sake by
default we attach all our handlers to the root logger. Thus all the
output handlers have equal opportunity to output a logging message
from one of the loggers.
Messages may be filtered by specifying a level. There are 3 places a
level may be set:
1) on the logger
2) on the handler
3) on the root logger (special case of item 1, global level)
A message has a level attached to it. The decision process of when to
emit a message works like this:
1) The path in the logger tree is walked from the logger to the root
logger. The first logger encountered with a level other than NOTSET
defines the effective level, if the message level is greater than
or equal to the effective level it is accepted for output. If only
NOTSET is found this becomes the effective level and the message is
accepted for output.
2) If the message passes the logging (category) level test then every
logger in the path from the logger to the root logger is given an
opportunity to emit the message by iterating over its list of
output handlers. If the message level is greater than or equal to
tbe level of the output handler it is output.
One consequence of this is that if an output handler is bound to both
the category logger and the root logger it will be emitted
twice. However, if you bind distinct output loggers to tbe category
logger and the root logger then each output logger may have its own
level and destination.
Note: the logging modules provides for propagation flags which stop
traversal to the root as well as filters for more complex filtering
then simple level testing, this offers more fine grained control.
Thus for a message to be output it must:
1) first pass the level test for the logging category.
2) secondly also pass the level test for every output handler bound to
every level in the path from the logger to the root.
It is tempting to want to set the global level on the root logger and
default the level on any category logger to NOTSET. This would cause
the root logger's level to take effect for any category logger without
an explicit level (e.g. the root logger is the default global
level). The notion of inheriting a level from your ancestors is nice,
but in practice its difficult to meet expectations using level
inheritance, instead we set a level on every logger and forego
inheritance, here's why:
If the root level was higher than an explicitly set category level the
message would be filtered. This would be counter to the expectation if
an explict level was set for any category it would be respected and
would be output. To get around this one could set the level on the
root logger to pass everything (e.g. NOTSET). This would allow
explicitly set category levels to be respected. However, if a
category did not have an explicit level set it would default to NOTSET
which would pass the message to the root, which being NOTSET would
pass the message to all of its output handlers. The effect would be
any category without an explicit level set would always output, this
also is not what is expected. The solution is not to try and set the
default global level on the root logger and depend on inheritance, but
rather explicitly set the level of every logger, either to the level
requested for that category, or to the default global level if an
explicit level is absent for the category.
Why is there a global debug flag that is checked before any call to
log_xxx.debug()? The logger.debug() function will check the levels and
not output anything if the level settings would prohibit the debug
message, clearly the debug flag is unnecessary, right? This is true,
however, if one considers the amount of work the logging library does
just to determine the log message will be discarded and observe that
in most all cases debug logging will be turned off this consititues a
performance hit, especially considering the large number of
logger.debug() calls throughout the code. In 'C' or similar languages
one could use preprocessor macros to eliminate debug logging in
production code, but this option is not available in python so we wrap
all logger.debug() calls in an 'if debug:' test to prevent spending
cycles on an operation which will be thrown away. Having a global
debug flag does require reevaluatiing it anytime the level of any
logging category changes because if any category is set for debug
logging the flag must be true so the loggers can be given a chance to
evaluate the message for their category.
t log_initt debugt profilet set_default_category_levelt set_category_levelt enable_log_outputt set_log_output_levelt dump_log_levelsN( t *c C s“ t o d Sn t a t d d ƒ } d | }
t i t i ƒ yY t i i
d d ƒ } | i t i ƒ | t
d <t i |
ƒ } | i | ƒ t d ƒ Wn0 t j
o$ } t i d | IJd t
d <n Xt i i | ƒ } d | } t t | d d
| ƒ ƒ a t | d d | ƒ } t | d d
| ƒ } t | d d | d ƒ } t | d d i# t$ ƒ | ƒ } t | d t& | t' ƒ } t | d t& | t' ƒ a) | o" t i i* t i i+ | ƒ ƒ } n t i | ƒ }
y7 t i- ƒ } | i t i ƒ | t
d <| i |
ƒ Wn t/ j
o d t
d <n X| o‡ yG t i0 | | ƒ } | i t i ƒ | t
d <| i |
ƒ t d ƒ Wq¸t/ j
o- } d t
d <t d ƒ t i2 d | ƒ q¸Xn d t
d <x* t3 | ƒ D] \ } } t | ƒ t6 | <qÅWt7 ƒ } xd t$ D]\ } d | } t i: | ƒ } | t< | <| | | <t= i> | ƒ t? t6 i@ | t i ƒ | ƒ qõWt) o tA i t iB ƒ n | o t d ƒ n tC t ƒ d S( Nt generalt pkg_names+ %s: [%%(name)s.%%(levelname)s] %%(message)st addresss /dev/logt syslogs* exception when creating syslog handler: %ss %s_logt levelt warningt filenamet filemodet wt formatt rawt
categoriest ,t consoleR t files+ Could not open log file (%s) - using stderrs log_%s(D t
log_init_donet Truet
get_configR
t
syslog_formatt root_loggert setLevelt loggingt NOTSETt handlerst
SysLogHandlert syslog_handlert ERRORt log_handlerst Formattert syslog_formattert setFormatterR t Exceptiont et syst stderrt Nonet ost patht basenamet program_namet config_sectiont map_levelt
get_optiont optionst global_levelR R R t joint LOG_CATEGORIESt cfg_categoriest Falset boolt console_flagR t
expandvarst
expandusert formattert
StreamHandlert console_handlert IOErrort FileHandlert file_handlert errort parse_log_categoriest
category_namet category_levelt config_category_levelt globalst gt logger_obj_namet getLoggert
logger_objt loggerst __all__t appendR t gett log_statst INFOR ( R0 R4 R8 RK RG RM R" R1 R R
R> R@ R R R) RF RJ R; RC R R& ( ( t6 /usr/lib/python2.4/site-packages/setroubleshoot/log.pyR ™ s‚
"
c C s‡ | d j o t i Sn y t | ƒ } WnX t j
oL | i ƒ } | d d d d d d g j o t i Sn t i | ƒ } n X| S( s7 Parse a string representing a level, map it to a numbert CRITICALR# t WARNINGRS t DEBUGR N( t map_strR, R R t intR
t
ValueErrort uppert getLevelName( RX R
( ( RT R2 s
c C s§ g } t i d ƒ } | i d ƒ } x| | D]t } | i | ƒ } | oX | i
d ƒ } | i
d ƒ } | i
d ƒ } | o
t i } n | i | | f ƒ q+ q+ W| S( sQ Iteratate over a category list in a string, return an array of pairs (name,level)s+ ^\s*(~\s*)?([^:\s]+)(\s*:\s*([^:\s]+))?\s*$R i i i N( t resultt ret compilet category_ret strt splitR t categoryt searcht matcht groupt negateRF RG R RU RP ( Ra Rc RF RG R] Rg R` R Re ( ( RT RE
s
c C s< t ƒ } t | t ƒ } | t i j o
t a n t a d S( sW If one or more logging categories are at debug level turn the
global debug flag on.N(
t get_min_category_levelt min_logger_levelt minR5 RG R RS R R R9 ( Ri RG ( ( RT t set_debug_flag s
c C sh t | ƒ } t i | ƒ } | o
| } n | } t i | ƒ } | p d Sn | i | ƒ t
ƒ d S( N( R2 t requested_levelRH RQ Rc t cfg_levelRG RN RM R Rk ( Rl Rc Rm RG RM ( ( RT R + s
c C s. x' t i ƒ D] \ } } t | | ƒ q
Wd S( N( RN t itemst logger_nameRM R Rl ( Rl RM Ro ( ( RT R 9 s
c C sT t i } xD t i ƒ D]6 } | i } | t i j o | | j o
| } q q W| S( N( R RU Ri RN t valuesRM R
RG R ( Ri RM RG ( ( RT Rh = s
c C so t i | ƒ } | p d Sn | o% | | i j o | i | ƒ qk n" | | i j o | i | ƒ n d S( N( R$ RQ t output_namet handlert enablet loggerR t
addHandlert
removeHandler( Rq Rs Rt Rr ( ( RT R F s c C sž t | ƒ } | d j o d d g } n t | ƒ t j p t | ƒ t j p
| g } n x; | D]3 } t i | ƒ } | d j o | i | ƒ qc qc Wd S( NR R ( R2 Rl R R, t typet ListTypet TupleTypet handler_nameR$ RQ t handler_objR ( Rl R R{ Rz ( ( RT R P s
&
c C sÓ d t i t ƒ t f GHd GHt i ƒ } | i ƒ x3 | D]+ } t i t | i ƒ } d | | f GHq: Wd GHt
i ƒ } | i ƒ xH | D]@ } t
| o t i t
| i ƒ } n d } d | | f GHq‹ Wd S( Ns Logging global_level=%s debug=%ss Loggers:s %-20s %ss Handlers:s
no handler(
R R\ R5 R RN t keyst logger_namest sortRo R
R$ t
handler_namesRz ( R} R
Ro Rz R ( ( RT R ^ s"
(" t __doc__RO R- R t logging.handlersR^ R* t typest setroubleshoot.configR9 R RN R$ RH RU Ri R R5 R R RL R R, R R2 RE Rk R R Rh R R R R ( R2 R R RE R R R Ri R^ R RN R$ R* R RO Rk Rh RH R R- ( ( RT t ?w s6
g