def get_logger(name=__name__, loglevel=logging.INFO, host='localhost'):
socket_handler = handlers.SocketHandler(host,
handlers.DEFAULT_TCP_LOGGING_PORT)
rootLogger.addHandler(socket_handler)
logging.info("Creating new logger {}".format(name))
new_logger = logging.getLogger(name)
new_logger.setLevel(loglevel)
return new_logger
def init_log(self, name, level, host, port, capacity=100):
target = handlers.SocketHandler(host, port)
if capacity > 0:
hdlr = handlers.MemoryHandler(capacity, logging.ERROR, target)
else:
hdlr = target
hdlr.setLevel(level)
self.logger = logging.getLogger(name)
self.logger.addHandler(hdlr)
self.logger.setLevel(level)
def get_logger(name, level, host, port, capacity=1024):
target = handlers.SocketHandler(host, port)
if capacity > 0:
hdlr = handlers.MemoryHandler(capacity, logging.ERROR, target)
else:
hdlr = target
hdlr.setLevel(level)
logger = logging.getLogger(name)
logger.addHandler(hdlr)
logger.setLevel(level)
return logger
def getSocketLogger(name, level, host, port, memoryCapacity):
target = handlers.SocketHandler(host, port)
if memoryCapacity > 0:
hdlr = handlers.MemoryHandler(
memoryCapacity,
logging.ERROR, # 此参数是指遇到此级别时，马上flush
target)
else:
hdlr = target
hdlr.setLevel(level)
logger = logging.getLogger(name)
logger.addHandler(hdlr)
logger.setLevel(level)
return logger
def log_wrapper(cls,
methods_to_log: tuple,
log_mode='local',
host=None,
port=None):
"""
:param cls: instance to be logged
:param methods_to_log: methods of instance to be logged (both method name, parameters, time
of invoking will be logged)
:param log_mode: 'local': log in local file (log.log)
'tcp' or 'udp': log to concrete host & port
:param host: target host if log mode is 'tcp' or 'udp'
:param port: port of target host if log mode is 'tcp' or 'udp'
:return: wrapped instance
"""
orig_cls = cls.__class__
logger = logging.getLogger(orig_cls.__name__)
if log_mode == 'tcp' or log_mode == 'udp':
handler = log_handlers.SocketHandler(
host=host,
port=port) if log_mode == 'tcp' else log_handlers.DatagramHandler(
host=host, port=port)
else:
if not os.path.exists(_log_file_name):
if system() == 'Windows':
open(_log_file_name, 'a').close()
else:
os.mknod(_log_file_name)
handler = logging.FileHandler(_log_file_name, mode='r+')
logger.addHandler(handler)
orig_methods = [
getattr(orig_cls, method) for method in methods_to_log
if hasattr(orig_cls, method)
]
logged_methods = [_log_wrapper(method, logger) for method in orig_methods]
for method in logged_methods:
setattr(orig_cls, method.__name__, method)
# bind logger with instance, so as to close log-handler when db closes
cls._logger = logger
return cls
def __init__(self, name, filehandler=False, sockethandler=True):
level_relations = {
'debug': logging.DEBUG,
'info': logging.INFO,
'warning': logging.WARNING,
'error': logging.ERROR,
'crit': logging.CRITICAL
} # 日志级别关系映射
self.logger = logging.getLogger(name)
self.logger.setLevel(level_relations[Log.baseLogLevel])
format_log = logging.Formatter(Log.fmt)
sh = logging.StreamHandler()
sh.setFormatter(format_log)
sh.setLevel(level_relations[Log.StreamHandlerlevel])
self.logger.addHandler(sh)
if sockethandler:
sockhandler = handlers.SocketHandler(Log.severip,
Log.socket_handler_port)
sockhandler.setLevel(level_relations[Log.sockhandlerLevel])
sockhandler.setFormatter(format_log)
self.logger.addHandler(sockhandler)
if filehandler:
filename = '{}.log'.format(name)
th = handlers.TimedRotatingFileHandler(
filename=filename,
when='D',
backupCount=30,
interval=1,
encoding='utf-8') # 往文件里写入#指定间隔时间自动生成文件的处理器
# 实例化TimedRotatingFileHandler
# interval是时间间隔，backupCount是备份文件的个数，如果超过这个个数，就会自动删除，when是间隔的时间单位，单位有以下几种：
# S 秒
# M 分
# H 小时、
# D 天、
# W 每星期（interval==0时代表星期一）
# midnight 每天凌晨
th.setLevel(level_relations[Log.filehandlerlevel])
th.setFormatter(format_log)
self.logger.addHandler(th)
LOG_MAX_BYTES = py_configs.PY_LOGS_MAX_BYTES
LOG_FILE_COUNT = py_configs.PY_LOGS_MAX_FILE_COUNT
LOG_ADDRESS = py_configs.PY_LOGS_ADDRESS
formatter = logging.Formatter(LOG_FORMAT)
logger = logging.getLogger('IMAGER')
logger.setLevel(LOG_LEVEL)
consoleHandler = logging.StreamHandler()
consoleHandler.setLevel(LOG_LEVEL)
consoleHandler.setFormatter(formatter)
fileHandler = handlers.RotatingFileHandler(LOG_FILENAME,
maxBytes=LOG_MAX_BYTES,
backupCount=LOG_FILE_COUNT)
fileHandler.setLevel(LOG_LEVEL)
fileHandler.setFormatter(formatter)
socketHandler = handlers.SocketHandler(LOG_ADDRESS,
handlers.DEFAULT_TCP_LOGGING_PORT)
logger.addHandler(socketHandler)
logger.addHandler(consoleHandler)
logger.addHandler(fileHandler)
THUMBNAIL_WIDTH = 1000
THUMBNAIL_HIGHT = 709
IMAGE_WAIT_TIMEOUT_CNT = 20
# image save folder
IMAGE_SAVE_PATH = "/mnt/ssd/imager/sensor"
RAW_DATA_FILENAME = "imager_data.bin"
class Imager(object):
logger.warning(
"skipping environ '{}={}' because exception '{}'".format(
env_k, env_v, e))
global_config["console_port_iterator"] = console_port_iterator
global_config["console_thread"] = {}
global_config["console_ports"] = {}
if not global_config["http_console_host"]:
global_config["http_console_host"] = global_config["http_host"]
if global_config["http_host"] == "0.0.0.0":
global_config["http_console_host"] = socket.gethostname()
# Configure logging STEP 2
if "log_host" in global_config:
socket_handler = log_handlers.SocketHandler(
global_config["log_socket_host"],
global_config["log_socket_port"])
socket_handler.setFormatter(log_formatter_complete)
if global_config.get("log_socket_level") \
and global_config["log_socket_level"] != global_config["log_level"]:
socket_handler.setLevel(global_config["log_socket_level"])
logger.addHandler(socket_handler)
if log_file:
global_config['log_file'] = log_file
elif global_config.get('log_file'):
set_logging_file(global_config['log_file'])
logger.setLevel(getattr(logging, global_config['log_level']))
logger.critical(
"Starting openmano server version: '%s %s' command: '%s'",
def __call__(self, state_machine_list, noimpl_flag, log_filename=None):
"""
Initialization of Python qf module and
startup of all state machine threads.
"""
global IMPL, ACTIVE
# Log to stdout only.
self.__logger_output_handler = logging.StreamHandler(sys.stdout)
# Connect to timeline GUI if it is running
self.__logger_output_socket = None
if self.__timeline_process is not None:
self.__logger_output_socket = handlers.SocketHandler('localhost', 7777)
#
if log_filename != None:
self.__logger_file_handler = logging.FileHandler(log_filename)
self.__logger_output_handler.setLevel(logging.INFO)
# Include only message in output.
#logger_formatter = logging.Formatter('%(thread)d:%(name)s %(message)s')
logger_formatter = logging.Formatter('%(message)s')
self.__logger_output_handler.setFormatter(logger_formatter)
#
#print "sys.modules:", sorted(sys.modules.keys())
smsToActivate = list()
for active in self.__active_modules:
names = map(lambda x: x + "Active", state_machine_list)
if (len(state_machine_list)==0) or (active in names)==True:
smsToActivate.append(active)
# Get actual module here.
mod = self.__active_modules_dict[active]
# Enable logger as info messages only.
mod.LOGGER.setLevel(logging.INFO)
mod.LOGGER.addHandler(self.__logger_output_handler)
if log_filename !=None:
print "Attaching log file handler: %s\n" % log_filename
mod.LOGGER.addHandler(self.__logger_file_handler)
#
# Add socket handler for timeline GUI.
#
if self.__timeline_process is not None:
mod.LOGGER.addHandler(self.__logger_output_socket)
#
# Instantiate and activate all StateMachines and impls first in
# separate loops to avoid dependency on order of logger setup, and to
# allow ACTIVE and IMPL dicts to be printed out before SM activation.
submImplsToFind = dict()
for active in smsToActivate:
sm_name = active.split("Active")[0]
sm_name_impl = sm_name + "Impl"
# Instance any Impl module and active object, excluding submachines
if active in self.__submachines_dict.keys():
if sm_name_impl in self.__impl_modules_dict.keys():
# No instancing; gather submachine impl for access via IMPL
submImplsToFind[sm_name] = active
else: # Active is NOT a submachine
mod = self.__active_modules_dict[active]
if sm_name_impl in self.__impl_modules_dict.keys():
mod_impl = self.__impl_modules_dict[sm_name_impl]
# Instance active object with impl instance here
impl = mod_impl.__dict__[sm_name_impl]()
s = mod.__dict__[active](impl)
IMPL[sm_name] = impl
else:
# Instance active object here without impl object
s = mod.__dict__[active]()
# Build global of active objects keyed on state machine name.
ACTIVE[sm_name] = s
#
# Find submachine Impls within the ACTIVE objects
# TODO only able to find submachines one-level down!
for subm_name in submImplsToFind.keys():
substate_name = self.__submachines_dict[submImplsToFind[subm_name]]
for sm_name in ACTIVE.keys():
mod = ACTIVE[sm_name]
try:
mod_impl = eval("mod._%sActive__%sImpl" % (sm_name, substate_name))
# found submachine impl! add to IMPL
IMPL[substate_name] = mod_impl
except AttributeError:
continue
#
# Print the accessible ACTIVE and IMPL objects
print "*Accessible Active and Impl objects:"
print " ACTIVE%s" % ACTIVE.keys()
print " IMPL%s" % IMPL.keys()
#
# Finally, activate the ACTIVEs
for s in ACTIVE.values():
# Active object start up and register with QF
s.startActive()
# start/initialize HSM
s.onStart(s.top)
s.start()
#!/usr/bin/env python3
# coding:utf-8
import logging
from logging import handlers
rootLogger = logging.getLogger('')
rootLogger.setLevel(logging.DEBUG)
socketHandler = handlers.SocketHandler('localhost', 9999)
# don't bother with a formatter, since a socket handler sends the event as
# an unformatted pickle
rootLogger.addHandler(socketHandler)
# Now we can log the root logger, or any other logger，First the root...
logging.info('Jackdaws love my big sphinx of quartz')
# Now, define a couple of other loggers which might represent areas in your
# application:
logger1 = logging.getLogger('myapp.area1')
logger2 = logging.getLogger('myapp.area2')
logger1.debug('Quick zephyrs blow, vexing daft Jim.')
logger1.info('How quickly daft jumping zebras vex.')
logger2.warning('Jail zesty vixen who grabbed pay from quack.')
logger2.error('The five boxing wizards jump quickly.')
def __init__(self, host, port, name, level):
self.logger = logging.getLogger(name)
hdlr = handlers.SocketHandler(host, port)
hdlr.setLevel(level)
self.logger.addHandler(hdlr)
self.logger.setLevel(level)