def _handle_logging(self, level, message):
"""
Handles an RPC logging request.
:param str level: One of "debug", "info", "warning", or "error".
:param str message: The log message.
"""
# manually create a record to log to the standard file handler.
# we format it to match the regular logs, but tack on the '.js' to
# indicate that it came from javascript.
record = logging.makeLogRecord({
"levelname": level.upper(),
"name": "%s.js" % (self.logger.name,),
"msg": message,
})
# forward this message to the base file handler so that it is logged
# appropriately.
if sgtk.LogManager().base_file_handler:
sgtk.LogManager().base_file_handler.handle(record)
python类makeLogRecord()的实例源码
def handle(self):
'''
Handle multiple requests - each expected to be a 4-byte length,
followed by the LogRecord in pickle format.
'''
while 1:
chunk = self.connection.recv(4)
if len(chunk) < 4:
break
slen = struct.unpack('>L', chunk)[0]
chunk = self.connection.recv(slen)
while len(chunk) < slen:
chunk = chunk + self.connection.recv(slen - len(chunk))
obj = self.unPickle(chunk)
record = logging.makeLogRecord(obj)
self.handleLogRecord(record)
def test_multiline_formatter():
import logging
from ldap2pg.config import MultilineFormatter
formatter = MultilineFormatter("prefix: %(message)s")
base_record = dict(
name='pouet', level=logging.DEBUG, fn="(unknown file)", lno=0, args=(),
exc_info=None,
)
record = logging.makeLogRecord(dict(base_record, msg="single line"))
payload = formatter.format(record)
assert "prefix: single line" == payload
record = logging.makeLogRecord(dict(base_record, msg="Uno\nDos\nTres"))
payload = formatter.format(record)
wanted = """\
prefix: Uno
prefix: Dos
prefix: Tres\
""".replace(' ', '')
assert wanted == payload
def read_logs(self):
try:
while True:
datagram = self.socket.recv(8192)
chunk = datagram[0:4]
struct.unpack(">L", chunk)[0]
chunk = datagram[4:]
obj = cPickle.loads(chunk)
record = logging.makeLogRecord(obj)
if (record.levelno >= self.level):
logger = logging.getLogger(record.name)
logger.handle(record)
except Exception as e:
print "ERROR: " + str(e)
finally:
self.socket.close()
def test_logger_format(self):
"""Test: CONFIG: logger format."""
config = SRBConfig(logger)
config.logger_add_stream_handler()
config.logger_add_file_handler('logs.log')
fmt = '%(name)s - %(levelname)s - %(message)s'
formatter = logging.Formatter(fmt)
config.logger_format = fmt
tst_record = {
'name': 'test_logger',
'level': logging.DEBUG,
'pathname': os.path.realpath(__file__),
'lineno': 42,
'msg': 'test_msg',
'args': None,
'exc_info': None,
'func': 'test_logger_format'
}
rec = logging.makeLogRecord(tst_record)
self.assertEqual(formatter.format(rec),
config.logger_stream_handler.format(rec))
def handle(self):
"""Handle multiple requests - each expected to be a 4-byte length,
followed by the LogRecord in pickle format. Logs the record
according to whatever policy is configured locally.
"""
while True:
chunk = self.connection.recv(4)
if len(chunk) < 4:
break
slen = struct.unpack('>L', chunk)[0]
chunk = self.connection.recv(slen)
while len(chunk) < slen:
chunk = chunk + self.connection.recv(slen - len(chunk))
obj = self.unpickle(chunk)
record = logging.makeLogRecord(obj)
self.handle_log_record(record)
def test_error_handling(self):
h = TestStreamHandler(BadStream())
r = logging.makeLogRecord({})
old_raise = logging.raiseExceptions
old_stderr = sys.stderr
try:
h.handle(r)
self.assertIs(h.error_record, r)
h = logging.StreamHandler(BadStream())
sys.stderr = sio = io.StringIO()
h.handle(r)
self.assertIn('\nRuntimeError: deliberate mistake\n',
sio.getvalue())
logging.raiseExceptions = False
sys.stderr = sio = io.StringIO()
h.handle(r)
self.assertEqual('', sio.getvalue())
finally:
logging.raiseExceptions = old_raise
sys.stderr = old_stderr
# -- The following section could be moved into a server_helper.py module
# -- if it proves to be of wider utility than just test_logging
def test_basic(self):
sockmap = {}
server = TestSMTPServer(('localhost', 0), self.process_message, 0.001,
sockmap)
server.start()
addr = ('localhost', server.port)
h = logging.handlers.SMTPHandler(addr, 'me', 'you', 'Log', timeout=5.0)
self.assertEqual(h.toaddrs, ['you'])
self.messages = []
r = logging.makeLogRecord({'msg': 'Hello'})
self.handled = threading.Event()
h.handle(r)
self.handled.wait(5.0) # 14314: don't wait forever
server.stop()
self.assertTrue(self.handled.is_set())
self.assertEqual(len(self.messages), 1)
peer, mailfrom, rcpttos, data = self.messages[0]
self.assertEqual(mailfrom, 'me')
self.assertEqual(rcpttos, ['you'])
self.assertIn('\nSubject: Log\n', data)
self.assertTrue(data.endswith('\n\nHello'))
h.close()
def test_error_handling(self):
h = TestStreamHandler(BadStream())
r = logging.makeLogRecord({})
old_raise = logging.raiseExceptions
old_stderr = sys.stderr
try:
h.handle(r)
self.assertIs(h.error_record, r)
h = logging.StreamHandler(BadStream())
sys.stderr = sio = io.StringIO()
h.handle(r)
self.assertIn('\nRuntimeError: deliberate mistake\n',
sio.getvalue())
logging.raiseExceptions = False
sys.stderr = sio = io.StringIO()
h.handle(r)
self.assertEqual('', sio.getvalue())
finally:
logging.raiseExceptions = old_raise
sys.stderr = old_stderr
# -- The following section could be moved into a server_helper.py module
# -- if it proves to be of wider utility than just test_logging
def test_basic(self):
sockmap = {}
server = TestSMTPServer((HOST, 0), self.process_message, 0.001,
sockmap)
server.start()
addr = (HOST, server.port)
h = logging.handlers.SMTPHandler(addr, 'me', 'you', 'Log',
timeout=self.TIMEOUT)
self.assertEqual(h.toaddrs, ['you'])
self.messages = []
r = logging.makeLogRecord({'msg': 'Hello \u2713'})
self.handled = threading.Event()
h.handle(r)
self.handled.wait(self.TIMEOUT) # 14314: don't wait forever
server.stop()
self.assertTrue(self.handled.is_set())
self.assertEqual(len(self.messages), 1)
peer, mailfrom, rcpttos, data = self.messages[0]
self.assertEqual(mailfrom, 'me')
self.assertEqual(rcpttos, ['you'])
self.assertIn('\nSubject: Log\n', data)
self.assertTrue(data.endswith('\n\nHello \u2713'))
h.close()
def handle(self):
"""
Handle multiple requests - each expected to be a 4-byte length,
followed by the LogRecord in pickle format. Logs the record
according to whatever policy is configured locally.
"""
while True:
chunk = self.connection.recv(4)
if len(chunk) < 4:
break
slen = struct.unpack('>L', chunk)[0]
chunk = self.connection.recv(slen)
while len(chunk) < slen:
chunk = chunk + self.connection.recv(slen - len(chunk))
obj = self.unPickle(chunk)
record = logging.makeLogRecord(obj)
self.handleLogRecord(record)
def test_error_handling(self):
h = TestStreamHandler(BadStream())
r = logging.makeLogRecord({})
old_raise = logging.raiseExceptions
old_stderr = sys.stderr
try:
h.handle(r)
self.assertIs(h.error_record, r)
h = logging.StreamHandler(BadStream())
sys.stderr = sio = io.StringIO()
h.handle(r)
self.assertIn('\nRuntimeError: deliberate mistake\n',
sio.getvalue())
logging.raiseExceptions = False
sys.stderr = sio = io.StringIO()
h.handle(r)
self.assertEqual('', sio.getvalue())
finally:
logging.raiseExceptions = old_raise
sys.stderr = old_stderr
# -- The following section could be moved into a server_helper.py module
# -- if it proves to be of wider utility than just test_logging
def test_basic(self):
sockmap = {}
server = TestSMTPServer(('localhost', 0), self.process_message, 0.001,
sockmap)
server.start()
addr = ('localhost', server.port)
h = logging.handlers.SMTPHandler(addr, 'me', 'you', 'Log',
timeout=self.TIMEOUT)
self.assertEqual(h.toaddrs, ['you'])
self.messages = []
r = logging.makeLogRecord({'msg': 'Hello'})
self.handled = threading.Event()
h.handle(r)
self.handled.wait(self.TIMEOUT) # 14314: don't wait forever
server.stop()
self.assertTrue(self.handled.is_set())
self.assertEqual(len(self.messages), 1)
peer, mailfrom, rcpttos, data = self.messages[0]
self.assertEqual(mailfrom, 'me')
self.assertEqual(rcpttos, ['you'])
self.assertIn('\nSubject: Log\n', data)
self.assertTrue(data.endswith('\n\nHello'))
h.close()
def test_color_handler():
import logging
from ldap2pg.config import ColoredStreamHandler
handler = ColoredStreamHandler()
record = logging.makeLogRecord(dict(
name='pouet', level=logging.DEBUG, fn="(unknown file)", msg="Message",
lno=0, args=(), exc_info=None,
))
payload = handler.format(record)
assert "\033[0" in payload
def update(self,frame,events):
if self._socket:
while self._socket.new_data:
t,s = self._socket.recv()
self.on_log(logging.makeLogRecord(s))
def recent_events(self,events):
if self._socket and self._socket.new_data:
t,s = self._socket.recv()
self.on_log(logging.makeLogRecord(s))
self.alpha -= min(.2,events['dt'])
def test_emitReturnsLoggedMessageId(self):
"""
MDKHandler.emit returns the LoggedMessageId from the Session.
"""
mdk, tracer = create_mdk_with_faketracer()
session = mdk.session()
handler = MDKHandler(mdk, lambda: session)
record = logging.makeLogRecord({"name": "", "levelname": "INFO",
"message": "hello"})
mid = handler.emit(record)
self.assertIsInstance(mid, LoggedMessageId)
self.assertEqual(mid.traceId, session._context.traceId)
def test_emitReturnsLoggedMessageId(self):
"""
MDKLoggingHandler.emit returns the LoggedMessageId.
"""
mdk, tracer = create_mdk_with_faketracer()
handler = MDKLoggingHandler(mdk)
record = logging.makeLogRecord({"name": "", "levelname": "INFO",
"message": "hello"})
mid = handler.emit(record)
self.assertIsInstance(mid, LoggedMessageId)
def handle(self):
"""Deal with the incoming log data"""
while True:
chunk = self.connection.recv(4)
if len(chunk) < 4:
break
struct_len = struct.unpack('>L', chunk)[0]
chunk = self.connection.recv(struct_len)
while len(chunk) < struct_len:
chunk = chunk + self.connection.recv(struct_len - len(chunk))
obj = self.unpickle(chunk)
record = logging.makeLogRecord(obj)
self.handle_log_record(record)
logging_aggregator.py 文件源码
项目：integration-prototype
作者: SKA-ScienceDataProcessor
项目源码
文件源码
阅读 35
收藏 0
点赞 0
评论 0
def run(self):
"""Run loop.
Receives log messages from connected publishers and logs them via
a python logging interface.
"""
log = logging.getLogger('sip.logging_aggregator')
fail_count = 0
fail_count_limit = 100
# Exponential relaxation of timeout in event loop.
timeout = np.logspace(-6, -2, fail_count_limit)
while not self._stop_requested.is_set():
try:
topic, values = self._subscriber.recv_multipart(zmq.NOBLOCK)
str_values = values.decode('utf-8')
try:
dict_values = json.loads(str_values)
record = logging.makeLogRecord(dict_values)
log.handle(record)
fail_count = 0
except json.decoder.JSONDecodeError:
print('ERROR: Unable to convert JSON log record.')
raise
except zmq.ZMQError as e:
if e.errno == zmq.EAGAIN:
fail_count += 1
else:
raise # Re-raise the exception
if fail_count < fail_count_limit:
_timeout = timeout[fail_count]
else:
_timeout = timeout[-1]
self._stop_requested.wait(_timeout)
def handle(self):
"""Handle multiple requests - each expected to be of 4-byte length,
followed by the LogRecord in pickle format. Logs the record
according to whatever policy is configured locally."""
while True:
chunk = self.connection.recv(4)
if len(chunk) < 4:
break
slen = struct.unpack(">L", chunk)[0]
chunk = self.connection.recv(slen)
while len(chunk) < slen:
chunk = chunk + self.connection.recv(slen - len(chunk))
obj = self.unpickle(chunk)
record = logging.makeLogRecord(obj)
self.handle_log_record(record)
def get_record(self, name=None):
result = dict(self.common)
if name is not None:
result.update(self.variants[name])
return logging.makeLogRecord(result)
def test_html_formatter_format():
formatter = formatters.HtmlFormatter()
logrecord = logging.makeLogRecord(dict(name='<foo>', func='<module>', msg='Whatsup?', funcName='test'))
s = formatter.format(logrecord)
assert '<foo>' not in s
assert '<module>' not in s
def test_html_formatter_emoji():
formatter = formatters.HtmlFormatter(use_emoji=True)
emoji_level_map = {
formatters.EMOJI.WHITE_CIRCLE: [logging.DEBUG],
formatters.EMOJI.BLUE_CIRCLE: [logging.INFO],
formatters.EMOJI.RED_CIRCLE: [logging.WARNING, logging.ERROR]
}
for emoji, levels in emoji_level_map.items():
for level in levels:
logrecord = logging.makeLogRecord({'levelno': level, 'levelname': logging.getLevelName(level)})
s = formatter.format(logrecord)
assert s.find(emoji) > 0, 'Emoji not found in %s' % level
def test_emit(handler):
record = logging.makeLogRecord({'msg': 'hello'})
with mock.patch('requests.post') as patch:
handler.emit(record)
assert patch.called
assert patch.call_count == 1
assert patch.call_args[1]['json']['chat_id'] == 'bar'
assert 'hello' in patch.call_args[1]['json']['text']
assert patch.call_args[1]['json']['parse_mode'] == 'HTML'
def test_emit_http_exception(handler):
record = logging.makeLogRecord({'msg': 'hello'})
with mock.patch('requests.post') as patch:
response = requests.Response()
response.status_code = 500
response._content = 'Server error'.encode()
patch.return_value = response
handler.emit(record)
assert telegram_handler.handlers.logger.handlers[0].messages['error']
assert telegram_handler.handlers.logger.handlers[0].messages['debug']
def test_emit_telegram_error(handler):
record = logging.makeLogRecord({'msg': 'hello'})
with mock.patch('requests.post') as patch:
response = requests.Response()
response.status_code = 200
response._content = json.dumps({'ok': False}).encode()
patch.return_value = response
handler.emit(record)
assert telegram_handler.handlers.logger.handlers[0].messages['warning']
def test_adds_padding(self):
self.handler.emit(logging.makeLogRecord({}))
self.d.infobox.assert_called_once_with(mock.ANY, 4, 10)
def test_args_in_msg_get_replaced(self):
assert len('123456') <= self.handler.width
self.handler.emit(logging.makeLogRecord(
{'msg': '123%s', 'args': (456,)}))
self.d.infobox.assert_called_once_with('123456', mock.ANY, mock.ANY)
def test_wraps_nospace_is_greedy(self):
assert len('1234567') > self.handler.width
self.handler.emit(logging.makeLogRecord({'msg': '1234567'}))
self.d.infobox.assert_called_once_with('123456\n7', mock.ANY, mock.ANY)
