class SenSysClient:
FAKE_DSN = '//key@domain/project'
def __init__(self, *args, **kwargs):
self.handler = SysLogHandler(address='/dev/log')
# it is important to separate `ident` with whitespace for syslog protocol
self.handler.ident = self.get_tag() + ' '
super().__init__(*args, **kwargs)
def get_tag(self):
raise NotImplementedError
def set_dsn(self, dsn=None, transport=None):
# it is important to pass `dsn` into `DjangoClient`,
# otherwise we could not retrieve message in `self.send()`
dsn = 'http:{}'.format(self.FAKE_DSN) if dsn is None else dsn
super().set_dsn(dsn, transport)
def send(self, auth_header=None, **data):
# support for standard Sentry Clients through `sensys` client
if self.get_public_dsn() != self.FAKE_DSN:
return super().send(auth_header, **data)
message = json.dumps(data, default=self.datetime_decode)
self.handler.emit(makeLogRecord({'msg': message}))
@staticmethod
def datetime_decode(obj):
if isinstance(obj, (datetime.datetime, datetime.date, datetime.time)):
return obj.isoformat()
def emit(self, record):
original_msg = record.msg
# this is needed to properly show the "initial-setup" prefix
# for log messages in syslog/Journal
record.msg = '%s: %s' % (self.tag, original_msg)
SysLogHandler.emit(self, record)
record.msg = original_msg
def emit(self, record):
"""
Emit the specified log record.
Provides the following:
- Replace newlines with spaces per syslog RFCs.
- Emit stack traces in following log records.
:param record: A log record.
:type record: LogRecord
"""
records = [record]
message = record.getMessage()
record.msg = LogHandler.clean(message)
record.args = tuple()
if record.exc_info:
msg = self.formatter.formatException(record.exc_info)
for line in msg.split('\n'):
_record = LogRecord(
name=record.name,
level=record.levelno,
pathname=record.pathname,
lineno=record.lineno,
msg=line,
args=tuple(),
exc_info=None)
records.append(_record)
record.exc_info = None
for r in records:
SysLogHandler.emit(self, r)
def emit(self, record):
if self.tag:
original_msg = record.msg
record.msg = '%s: %s' % (self.tag, original_msg)
SysLogHandler.emit(self, record)
record.msg = original_msg
else:
SysLogHandler.emit(self, record)
def emit(self, record):
try:
SysLogHandler.emit(self, record)
if self.fallback:
self._fallback_logging("Connection to syslog re-established. "
"Will do logging there from now on")
self.fallback = False
except ResilientSysLogHandler.FallbackException:
pass
class RsyslogEmitter(object):
def __init__(self):
self.handler = None
def emit(self, entry):
if self.handler is None:
self.handler = SysLogHandler(address='/dev/log', facility='user')
record = logging.LogRecord('diary-rsyslogger', logging.INFO, None,
None, 'ADMINDIARY: ' + str(entry), (), None,
None)
self.handler.emit(record)
def emit(self, record):
"""
Wrapper method for SysLogHandler.emit() to encode an unicode message
to UTF-8 (or whatever).
"""
msg = record.msg
if sys.version_info[0] > 2:
if isinstance(msg, bytes):
msg = msg.decode(self.encoding)
record.msg = msg
else:
if isinstance(msg, unicode): # noqa
msg = msg.encode(self.encoding)
record.msg = msg
SysLogHandler.emit(self, record)
class RsyslogEmitter(object):
def __init__(self):
self.handler = None
def emit(self, entry):
if self.handler is None:
if os.path.exists('/dev/log'):
self.handler = SysLogHandler(address='/dev/log',
facility='user')
else:
get_logger().error(
'RsyslogEmitter().emit() failed: /dev/log does not exist, cannot emit entry (%s)'
% (entry, ))
return
record = logging.LogRecord('diary-rsyslogger', logging.INFO, None,
None, 'ADMINDIARY: ' + str(entry), (), None,
None)
self.handler.emit(record)
def emit(self, record):
message = record.getMessage()
msg_len = len(message)
if msg_len > self.MTU:
# Chunk message into MTU size parts
start_index = 0
end_index = self.MTU - 1
while True:
msg = message[start_index:end_index]
rec = logging.LogRecord(record.name, record.levelno, record.pathname, record.lineno, msg, None, record.exc_info, record.funcName)
SysLogHandler.emit(self, rec)
start_index = start_index + self.MTU
if start_index >= msg_len:
break
end_index = end_index + self.MTU
if end_index > msg_len:
end_index = msg_len - 1
else:
SysLogHandler.emit(self, record)
class SyslogHandler(Handler):
syslogger = None
def __init__(self, server, port):
Handler.__init__(self)
self.syslogger = SysLogHandler(address=(server, port))
assert syslog is not None, "Syslog module not present"
def close(self):
pass
def reopen(self):
pass
def emit(self, record):
params = record.asdict()
self.syslogger.emit(SysLogRecord(msg=record.msg,
level=record.level,
args=params,
exc_info=None,
pathname=None,
lineno=None,
name=None))
class SyslogLogger(object):
__syslog_handler = None
def __init__(self, address, frmt=None):
self.__syslog_handler = SysLogHandler(address)
if frmt is None or frmt == "msg_only":
self.__syslog_handler.formatter = SyslogLoggerMsgOnlyFormatter()
else:
self.__syslog_handler.formatter = SyslogLoggerJSONFormatter()
def close(self):
self.__syslog_handler.close()
def msg(self, event_dict):
record = LogRecord(event_dict.get("name", "unknown"),
event_dict.get("level", "WARNING"),
"/not_used/not_used.py", 1,
event_dict, [], None)
self.__syslog_handler.acquire()
try:
self.__syslog_handler.emit(record)
finally:
self.__syslog_handler.release()
def emit(self, record):
original_msg = record.msg
record.msg = '%s: %s' %(self.tag, original_msg)
SysLogHandler.emit(self, record)
record.msg = original_msg
