1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
# -*- test-case-name: twisted.logger.test.test_observer -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.
"""
Basic log observers.
"""
from zope.interface import Interface, implementer
from twisted.python.failure import Failure
from ._logger import Logger
OBSERVER_DISABLED = (
"Temporarily disabling observer {observer} due to exception: {log_failure}"
)
class ILogObserver(Interface):
"""
An observer which can handle log events.
Unlike most interfaces within Twisted, an L{ILogObserver} I{must be
thread-safe}. Log observers may be called indiscriminately from many
different threads, as any thread may wish to log a message at any time.
"""
def __call__(event):
"""
Log an event.
@type event: C{dict} with (native) C{str} keys.
@param event: A dictionary with arbitrary keys as defined by the
application emitting logging events, as well as keys added by the
logging system. The logging system reserves the right to set any
key beginning with the prefix C{"log_"}; applications should not
use any key so named. Currently, the following keys are used by
the logging system in some way, if they are present (they are all
optional):
- C{"log_format"}: a PEP-3101-style format string which draws
upon the keys in the event as its values, used to format the
event for human consumption.
- C{"log_flattened"}: a dictionary mapping keys derived from
the names and format values used in the C{"log_format"}
string to their values. This is used to preserve some
structured information for use with
L{twisted.logger.extractField}.
- C{"log_trace"}: A L{list} designed to capture information
about which L{LogPublisher}s have observed the event.
- C{"log_level"}: a L{log level
<twisted.logger.LogLevel>} constant, indicating the
importance of and audience for this event.
- C{"log_namespace"}: a namespace for the emitter of the event,
given as a unicode string.
- C{"log_system"}: a string indicating the network event or
method call which resulted in the message being logged.
"""
@implementer(ILogObserver)
class LogPublisher(object):
"""
I{ILogObserver} that fans out events to other observers.
Keeps track of a set of L{ILogObserver} objects and forwards
events to each.
"""
def __init__(self, *observers):
self._observers = list(observers)
self.log = Logger(observer=self)
def addObserver(self, observer):
"""
Registers an observer with this publisher.
@param observer: An L{ILogObserver} to add.
"""
if not callable(observer):
raise TypeError("Observer is not callable: {0!r}".format(observer))
if observer not in self._observers:
self._observers.append(observer)
def removeObserver(self, observer):
"""
Unregisters an observer with this publisher.
@param observer: An L{ILogObserver} to remove.
"""
try:
self._observers.remove(observer)
except ValueError:
pass
def __call__(self, event):
"""
Forward events to contained observers.
"""
if "log_trace" in event:
def trace(observer):
"""
Add tracing information for an observer.
@param observer: an observer being forwarded to
@type observer: L{ILogObserver}
"""
event["log_trace"].append((self, observer))
else:
trace = None
brokenObservers = []
for observer in self._observers:
if trace is not None:
trace(observer)
try:
observer(event)
except Exception:
brokenObservers.append((observer, Failure()))
for brokenObserver, failure in brokenObservers:
errorLogger = self._errorLoggerForObserver(brokenObserver)
errorLogger.failure(
OBSERVER_DISABLED,
failure=failure,
observer=brokenObserver,
)
def _errorLoggerForObserver(self, observer):
"""
Create an error-logger based on this logger, which does not contain the
given bad observer.
@param observer: The observer which previously had an error.
@type observer: L{ILogObserver}
@return: L{None}
"""
errorPublisher = LogPublisher(*[
obs for obs in self._observers
if obs is not observer
])
return Logger(observer=errorPublisher)
|
