def formatEvent(_event: dict) -> str:
event = dict(_event)
event["log_level"] = event["log_level"].name.upper()
event[
"log_format"] = "- {log_namespace} - {log_level} - {request} - " + (
event.get("log_format", "{log_text}") or "{log_text}")
return eventAsText(event, includeSystem=False) + "\n"
def _log(event):
if "log_text" in event:
if event["log_text"].startswith(
"DNSDatagramProtocol starting on "):
return
if event["log_text"].startswith("(UDP Port "):
return
if event["log_text"].startswith("Timing out client"):
return
# this is a workaround to make sure we don't get stack overflows when the
# logging system raises an error which is written to stderr which is redirected
# to the logging system, etc.
if getattr(threadlocal, "active", False):
# write the text of the event, if any, to the *real* stderr (which may
# be redirected to /dev/null, but there's not much we can do)
try:
event_text = eventAsText(event)
print("logging during logging: %s" % event_text,
file=sys.__stderr__)
except Exception:
# gah.
pass
return
try:
threadlocal.active = True
return observer(event)
finally:
threadlocal.active = False
def test_log_output(self):
"""
When a structured logging config is given, Synapse will use it.
"""
beginner = FakeBeginner()
publisher = setup_logging(self.hs,
self.hs.config,
logBeginner=beginner)
# Make a logger and send an event
logger = Logger(namespace="tests.logging.test_structured",
observer=publisher)
with LoggingContext("testcontext", request="somereq"):
logger.info("Hello there, {name}!", name="steve")
with open(self.homeserver_log, "r") as f:
logged_events = [
eventAsText(x, includeTimestamp=False)
for x in eventsFromJSONLogFile(f)
]
logs = "\n".join(logged_events)
self.assertTrue("***** STARTING SERVER *****" in logs)
self.assertTrue("Hello there, steve!" in logs)
def event_to_string(event):
# "t.i.protocol.Factory" produces a bunch of 'starting' and
# 'stopping' messages that are quite noisy in the logs (and
# don't provide useful information); skip them.
if isinstance(event.get("log_source", None), Factory):
return
# docstring seems to indicate eventAsText() includes a
# newline, but it .. doesn't
return u"{}\n".format(eventAsText(event, includeSystem=False))
def main():
if Config.get('logging')['verbose'] is True:
globalLogPublisher.addObserver(
FileLogObserver(sys.stdout, lambda e: eventAsText(e) + "\n"))
if Config.get('logging')['log_to_file'] is True:
logfile = os.path.join(os.path.abspath(os.path.dirname(__file__)),
"logs/log.json")
globalLogPublisher.addObserver(
jsonFileLogObserver(io.open(logfile, 'w+'), ''))
server = Server(Config.get('server')['port'])
server.run()
def test_output_to_json_round_trip(self):
"""
Synapse logs can be outputted to JSON and then read back again.
"""
temp_dir = self.mktemp()
os.mkdir(temp_dir)
self.addCleanup(shutil.rmtree, temp_dir)
json_log_file = os.path.abspath(os.path.join(temp_dir, "out.json"))
log_config = {
"drains": {
"jsonfile": {
"type": "file_json",
"location": json_log_file
}
}
}
# Begin the logger with our config
beginner = FakeBeginner()
setup_structured_logging(self.hs,
self.hs.config,
log_config,
logBeginner=beginner)
# Make a logger and send an event
logger = Logger(namespace="tests.logging.test_structured",
observer=beginner.observers[0])
logger.info("Hello there, {name}!", name="wally")
# Read the log file and check it has the event we sent
with open(json_log_file, "r") as f:
logged_events = list(eventsFromJSONLogFile(f))
self.assertEqual(len(logged_events), 1)
# The event pulled from the file should render fine
self.assertEqual(
eventAsText(logged_events[0], includeTimestamp=False),
"[tests.logging.test_structured#info] Hello there, wally!",
)
'allow_management': 'False'
},
'auto_rx': {
'address': 'http://localhost:5000',
'path': '/home/pi/radiosonde_auto_rx',
'telemetry_port': '55673'
}
}
CONFIG_FILE_LIST = [
'/etc/rs_agent.conf', '~/.rs_agent.conf', '~/.config/rs_agent/config.conf',
'config.conf'
]
log = Logger()
log.observer.addObserver(
FileLogObserver(sys.stdout, lambda e: eventAsText(e) + "\n"))
class HorusRepeater(protocol.DatagramProtocol):
def __init__(self, server_iface):
self.iface = server_iface
def datagramReceived(self, datagram, address):
self.iface.callRemote('upload_telemetry', datagram)
def any_active_sdr(jdict):
'''Are any of the sdrs not scanning or idle'''
allowed = ['Scanning', 'Not Tasked']
return all(state not in allowed for _, state in jdict.items())
def appendEvent(self, event):
self._history.insert(0, eventAsText(event))
self.historyChanged.emit()
def event_to_string(event):
# docstring seems to indicate eventAsText() includes a
# newline, but it .. doesn't
return u"{}\n".format(eventAsText(event, includeSystem=False))