def _create_logger(log_dir_path, logger_name, log_file_enabled, log_params):
logger = logging.getLogger(logger_name)
# Setup format
formatter = Formatter(fmt='%(asctime)s %(levelname)7s: %(message)s', datefmt='%Y/%m/%d %p %I:%M:%S',)
# Enable console output
console = logging.StreamHandler()
console.level = log_params['level']
console.formatter = formatter
logger.addHandler(console)
# Enable file output with rotation
if log_file_enabled:
log_file_path = os.path.join(log_dir_path, logger_name + ".log")
file_handler = RotatingFileHandler(
filename=log_file_path,
mode='a',
maxBytes=log_params['max_bytes'],
backupCount=log_params['backup_count']
)
file_handler.level = log_params['level']
file_handler.formatter = formatter
logger.addHandler(file_handler)
logging.getLogger().setLevel(logging.DEBUG)
return logger
def init_logging(bot_name,
path=None,
level=logging.INFO,
encoding="gbk",
format_string=_FORMATTER,
**kwargs):
global _MAX_BYTES, _BACKUP_COUNT, _FILE_DELAY
if isinstance(level, str):
level = getattr(logging, level.upper())
if "maxBytes" in kwargs.keys():
_MAX_BYTES = kwargs["maxBytes"]
if "backupCount" in kwargs.keys():
_BACKUP_COUNT = kwargs["backupCount"]
if "delay" in kwargs.keys():
_FILE_DELAY = kwargs["delay"]
fn = "scrapy-{}.log".format(bot_name)
if path:
ph = join(path, fn)
else:
ph = fn
formatter = logging.Formatter(format_string)
ch = logging.StreamHandler(sys.stdout)
ch.name = "ext_ch"
ch.setFormatter(formatter)
fh = RotatingFileHandler(
filename=ph,
maxBytes=_MAX_BYTES,
backupCount=_BACKUP_COUNT,
encoding=encoding,
delay=_FILE_DELAY,
)
fh.name = "ext_fh"
fh.level = level
fh.setFormatter(formatter)
if fh.name not in [h.name for h in logging.getLogger("scrapy").handlers]:
logging.getLogger("scrapy").addHandler(fh)
def init_logger(app: Flask):
"""
This method initialize the logger
@param app: the Flask app
"""
sqlalchemy_logger = logging.getLogger('sqlalchemy.engine')
log_level = logging.INFO
if app.config['LOGLEVEL']:
log_level = logging._nameToLevel[app.config['LOGLEVEL']]
app.logger.setLevel(log_level)
# set logging level to one level more than given level, because INFO level of sqlalchemy is too verbose
if log_level == 10:
sqlalchemy_logger.setLevel(log_level)
else:
sqlalchemy_logger.setLevel(log_level + 10)
stdout_handler = logging.StreamHandler(sys.stdout)
stdout_handler.setFormatter(
logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'
)
)
app.logger.addHandler(stdout_handler)
sqlalchemy_logger.addHandler(stdout_handler)
# if we are not in debug mode add log file
if not app.debug:
# create a logger file handler to store logs
file_handler = RotatingFileHandler(app.config['API_LOGFILE'], encoding='utf-8', maxBytes=500)
file_handler.level = log_level
file_handler.setFormatter(Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'
))
app.logger.addHandler(file_handler)
sqlalchemy_logger.addHandler(file_handler)
app.logger.info('Logger correctly set')
app.logger.info('Encoding : ' + getpreferredencoding())
def __init__(
self,
name=sys.argv[0], # type: Optional[str]
*,
stdout=None, # type: Optional[bool]
filepath=None, # type: Optional[str]
level='', # type: str
propagate=False # type: bool
):
# type: (...) -> None
"""
Args:
name: Set Logger name. When you want to use root logger, set None.
stdout: Set True when needing stdout.
filepath: Set file path to output logs.
level: Choose from `Logger.LEVELS`.
propagate: Set logger.propagate when some configurations setted.
Exceptions:
TypeError: Log level is empty when setting some configurations,
because empty level would make bug.
"""
self._logger = getLogger(str(name))
if not level and (stdout or filepath):
raise TypeError("Set log level when setting some configurations")
elif level:
self._logger.setLevel(self.LEVELS[level])
self._logger.propagate = propagate
if stdout is not None and stdout:
stdout_handler = SH(sys.stdout)
stdout_handler.setFormatter(Formatter(self.LOGFMT))
stdout_handler.setLevel(self.LEVELS[level])
self._logger.addHandler(stdout_handler)
self._logger.propagate = propagate
if filepath is not None and filepath:
file_handler = RFH(filepath, 'a+', 100000, 100)
file_handler.setFormatter(Formatter(self.LOGFMT))
file_handler.level = self.LEVELS[level]
self._logger.addHandler(file_handler)
self._logger.propagate = propagate
import time
import splunk.entity as entity
import csv
import logging
from logging.handlers import RotatingFileHandler
logger = logging.getLogger('ts_webhook_alert')
logger.setLevel(logging.DEBUG)
try:
fh = RotatingFileHandler('%s/var/log/splunk/ts_webhook.log' %
os.environ['SPLUNK_HOME'],
backupCount=3)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
fh.level = logging.DEBUG
logger.addHandler(fh)
except Exception:
pass
def gunzip(gzfile):
"""
Uncompress the results file and sanitize it for import.
Splunk results file by default contains columns which don't play nice with TS import
"""
logger.info("Processing results file %s" % gzfile)
if gzfile.endswith(".gz"):
results_file = gzip.open(gzfile, 'rb')
else:
import json
from config import windowsoptions
from login import login
from effects import *
from childpages import *
from guiutil import set_skin, set_bg
import utildialog
#主日志保存在log/ifpms.log
logging.root.setLevel(logging.INFO)
logging.root.propagate = 0
loghandler = RotatingFileHandler(os.path.join("log", "config.log"), maxBytes=10 * 1024 * 1024, backupCount=100)
loghandler.setFormatter(logging.Formatter('%(asctime)s %(levelname)8s [%(filename)16s:%(lineno)04s] %(message)s'))
loghandler.level = logging.INFO
logging.root.addHandler(loghandler)
logger = logging.root
logger.propagate = 0
class MetroWindow(QtGui.QWidget):
def __init__(self, parent=None):
super(MetroWindow, self).__init__(parent)
self.page_tag = windowsoptions['mainwindow']['centralwindow']['page_tag']
self.page_tag_zh = windowsoptions['mainwindow']['centralwindow']['page_tag_zh']
self.initUI()
def initUI(self):
