def __init__(self, pipeline_id=None, host='127.0.0.1', port=50001):
super(PipelineCallback, self).__init__()
self._pipeline_id = pipeline_id if pipeline_id is not None else uuid4().hex
self.logger = logging.getLogger(pipeline_id)
handler = DatagramHandler(host, port)
formatter = logging.Formatter(fmt="%(message)s")
handler.setFormatter(formatter)
handler.setLevel(logging.INFO)
self.logger.addHandler(handler)
self.logger.setLevel(logging.INFO)
def config_logging(suffix=""):
from logging.handlers import TimedRotatingFileHandler, DatagramHandler
base_format = logging.Formatter("%(asctime)s %(levelname)s %(message)s", "%Y-%m-%d %H:%M:%S")
filename = "log-" + suffix + ".log"
file_handler = TimedRotatingFileHandler(filename=filename, when='midnight', backupCount=15)
file_handler.setFormatter(base_format)
logging.getLogger().addHandler(file_handler)
udp_handler = DatagramHandler(host="10.47.54.115", port=10000) # 设置 udp 服务器地址
udp_handler.setFormatter(base_format)
udp_handler.setLevel(level=logging.ERROR)
logging.getLogger().addHandler(udp_handler)
logging.getLogger().setLevel(level=logging.INFO)
def add_handlers(self, logger, formatter):
for h in HANDLERS:
handler = False
if h == 'stderr':
handler = StreamHandler()
elif h == 'file':
if LOGFILE is not None:
handler = FileHandler(filename=LOGFILE)
elif h == 'server':
if HOST is not None and PORT is not None:
handler = DatagramHandler(host=HOST, port=int(PORT))
if handler is not False:
handler.setLevel(logging.INFO)
handler.setFormatter(formatter)
logger.addHandler(handler)
return(logger)
def new_logger(self):
"""Create default logs"""
logger = logging.getLogger(self.basename)
handler = DatagramHandler('localhost', DEFAULT_UDP_LOGGING_PORT)
logger.addHandler(handler)
_level = (self.kwargs.get("level") or "INFO").upper()
if _level == "DEBUG" or _level == "INFO":
logger.setLevel(logging.INFO)
elif _level == "WARNING":
logger.setLevel(logging.WARNING)
elif _level == "ERROR":
logger.setLevel(logging.ERROR)
elif _level == "CRITICAL":
logger.setLevel(logging.CRITICAL)
else:
logger.setLevel(logging.ERROR)
return logger
def init_logging(logger=None, level="DEBUG", log_file="", init_handler=None,
max_count=30, propagate=False, file_config=None, dict_config=None,
unix_domain=None):
fmt = DEFAULT_FMT
datefmt = "%Y-%m-%d %H:%M:%S"
formatter = logging.Formatter(fmt=fmt, datefmt=datefmt)
level = getattr(logging, level.upper())
if log_file:
if init_handler:
handler = init_handler(log_file, max_count)
else:
handler = TimedRotatingFileHandler(log_file, when="midnight",
interval=1, backupCount=max_count)
elif unix_domain:
handler = DatagramHandler(unix_domain, None)
else:
handler = logging.StreamHandler()
handler.setLevel(level)
handler.setFormatter(formatter)
# Initialize the argument logger with the arguments, level and log_file.
root = logging.getLogger()
if logger:
loggers = logger if isinstance(logger, (list, tuple)) else [logger]
for _logger in loggers:
_logger.propagate = propagate
_logger.setLevel(level)
_logger.addHandler(handler)
if root and root is _logger:
root = None
if root:
root.propagate = propagate
root.setLevel(level)
root.addHandler(handler)
# Initialize logging by the configuration file, file_config.
if file_config:
logging.config.fileConfig(file_config, disable_existing_loggers=False)
# Initialize logging by the dict configuration, dict_config.
if dict_config and hasattr(logging.config, "dictConfig"):
logging.config.dictConfig(dict_config)
def log_init(log_path):
_logger = logging.getLogger(logger_name)
file_name = str(log_path).split('/')[-1].split('.')[0]
datefmt = '%Y-%m-%d %I:%M:%S %p'
fmt = '%(asctime)s-[%(levelname)s]-[' + file_name + ']: %(message)s'
_logger.setLevel(logging.DEBUG)
fh = logging.FileHandler(log_path)
fh.setLevel(logging.ERROR)
fh.setFormatter(Formatter(fmt, datefmt))
_logger.addHandler(fh)
ch = logging.StreamHandler(sys.stdout)
ch.setLevel(logging.DEBUG)
ch.setFormatter(MyFormatter(fmt, datefmt))
_logger.addHandler(ch)
uh = DatagramHandler(const.const.TLOG_ADDR[0], const.const.TLOG_ADDR[1])
uh.setLevel(logging.CRITICAL)
uh.setFormatter('%(message)s')
def __init__(self, sName='', nPort=0):
pPy = config.logger.get('dir')
self.pHome = pPy + s
log_level = config.logger.get('level')
if not log_level: log_level = 'INFO'
kLevel = _LOG_LEVEL_DICT.get(log_level)
oLogger = getLogger(gHost)
oLogger.propagate = 0
oLogger.setLevel(kLevel)
self.oLogger = oLogger
self.log = self.oLogger
if nPort:
self.hLog = DatagramHandler(sName, nPort)
self.log.addHandler(self.hLog)
elif sName:
self.sName = sName
self.pLog = ''
Global.log = property(_logger)
else:
self.init_logger()
sys_formatter = logging.Formatter(sys_format)
# Console - all log messages with streamhandler
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)
console_handler.setFormatter(def_formatter)
# Filehandler - warning and higher messages only, include current time
# filename: {todays-date}.log
# shares format with console/streamhandler
file_handler = logging.FileHandler(f'{today_date}.log')
file_handler.setLevel(logging.WARNING)
file_handler.setFormatter(def_formatter)
# SysLog Server - error and higher messages only, does not include current time
sys_handler = DatagramHandler(host='127.0.0.1', port=514)
sys_handler.setLevel(logging.ERROR)
sys_handler.setFormatter(sys_formatter)
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
logger.addHandler(file_handler)
logger.addHandler(console_handler)
logger.addHandler(sys_handler)
def my_fun(n):
for i in range(0, n):
logging.debug(i)
if i == 50:
logging.warning("The value of i is 50.")
log_format = "%(asctime)s %(filename)s:%(lineno)-4d %(levelname)s %(message)s"
log_format_serv = "%(filename)s:%(lineno)-4d %(levelname)s %(message)s"
formatter = logging.Formatter(log_format)
formatter_serv = logging.Formatter(log_format_serv)
file_handler = logging.FileHandler('{}.log'.format(datetime.date.today()))
file_handler.setLevel(logging.WARNING)
file_handler.setFormatter(formatter)
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)
console_handler.setFormatter(formatter)
syslog_handler = DatagramHandler('127.0.0.1', 514)
syslog_handler.setLevel(logging.ERROR)
syslog_handler.setFormatter(formatter_serv)
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
logger.addHandler(file_handler)
logger.addHandler(console_handler)
logger.addHandler(syslog_handler)
def my_fun(n):
for i in range(0, n):
logging.debug(i)
if i == 50:
logging.warning("The value of i is 50.")
sysformat = "%(filename)s:%(lineno)-4d %(levelname)s %(message)s"
today = datetime.date.today()
formatter = logging.Formatter(format)
sysformatter = logging.Formatter(sysformat)
file_handler = logging.FileHandler('{}.log'.format(today))
file_handler.setLevel(logging.WARNING)
file_handler.setFormatter(formatter)
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)
console_handler.setFormatter(formatter)
syslog_handler = DatagramHandler("127.0.0.1", 514)
syslog_handler.setLevel(logging.ERROR)
syslog_handler.setFormatter(sysformatter)
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
logger.addHandler(file_handler)
logger.addHandler(console_handler)
logger.addHandler(syslog_handler)
def my_fun(n):
for i in range(0, n):
logging.debug(i)
if i == 50:
logging.warning("The value of i is 50.")
HOST, PORT = "localhost", 514
format = "%(asctime)s %(filename)s:%(lineno)-3d %(levelname)s %(message)s"
syslog_format = "%(filename)s:%(lineno)-3d %(levelname)s %(message)s"
formatter = logging.Formatter(format)
file_handler = logging.FileHandler(f"{date.today()}.log")
file_handler.setLevel(logging.WARNING)
file_handler.setFormatter(formatter)
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)
console_handler.setFormatter(formatter)
syslog_server_handler = DatagramHandler(HOST, PORT)
syslog_server_handler.setLevel(logging.ERROR)
syslog_server_handler.setFormatter(syslog_format)
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
logger.addHandler(file_handler)
logger.addHandler(console_handler)
logger.addHandler(syslog_server_handler)
def my_fun(n):
for i in range(0, n):
logging.debug(i)
if i == 50:
logging.warning("The value of i is 50.")
def udpHandler(self):
udp_handler = DatagramHandler('127.0.0.1', 3333)
udp_handler.setLevel(self.log_level)
udp_handler.setFormatter(self.formatter)
self.logger.addHandler(udp_handler)
log_format_server = "%(filename)s:%(lineno)-4d %(levelname)s %(message)s"
log_format = "%(asctime)s %(filename)s:%(lineno)-3d %(levelname)s %(message)s"
formatter_server = logging.Formatter(log_format_server)
formatter = logging.Formatter(log_format)
file_handler = logging.FileHandler('mylog.log')
file_handler.setLevel(logging.WARNING) # Add this line
file_handler.setFormatter(formatter)
console_handler = logging.StreamHandler() # Add this line
console_handler.setLevel(logging.DEBUG) # Add this line
console_handler.setFormatter(formatter) # Add this line
syslog_handler = DatagramHandler('0.0.0.0', 514)
syslog_handler.setLevel(logging.ERROR)
syslog_handler.setFormatter(formatter_server)
logger = logging.getLogger()
logger.addHandler(syslog_handler)
logger.setLevel(logging.DEBUG) # Add this line
logger.addHandler(file_handler)
logger.addHandler(console_handler) # Add this line
def my_fun(n):
for i in range(0, n):
logging.debug(i)
if i == 50:
