def setup_logging(lf_enabled=True, lc_enabled=True):
logger = logging.getLogger('sonarr_youtubedl')
logger.setLevel(logging.INFO)
log_format = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
if lf_enabled:
# setup logfile
log_file = os.path.abspath(
os.path.join(os.path.dirname(__file__), '..', 'logs'))
log_file = os.path.abspath(log_file + '/sonarr_youtubedl.log')
loggerfile = RotatingFileHandler(log_file,
maxBytes=5000000,
backupCount=5)
loggerfile.setLevel(logging.INFO)
loggerfile.set_name('FileHandler')
loggerfile.setFormatter(log_format)
logger.addHandler(loggerfile)
if lc_enabled:
# setup console log
loggerconsole = logging.StreamHandler()
loggerconsole.setLevel(logging.INFO)
loggerconsole.set_name('StreamHandler')
loggerconsole.setFormatter(log_format)
logger.addHandler(loggerconsole)
return logger
def initLogFile(formatDict):
noHandler = True
# Initialize noHandle
for handler in log.handlers: # Iterate over all ha
if handler.get_name() == formatDict['name']: # If handler name mat
noHandler = False
# Set no handler fals
break
# Break for loop
if noHandler:
logDir = os.path.dirname(formatDict['file'])
if not os.path.isdir(logDir):
os.makedirs(logDir)
rfh = RotatingFileHandler(formatDict['file'], **ROTATING_FORMAT)
rfh.setFormatter(formatDict['formatter'])
rfh.setLevel(formatDict['level']) # Set the logging lev
rfh.set_name(formatDict['name']) # Set the log name
log.addHandler(rfh) # Add hander to the m
info = os.stat(formatDict['file'])
# Get information abo
if (info.st_mode & formatDict['permissions']
) != formatDict['permissions']: # If the permissions
try: # Try to
os.chmod(formatDict['file'], formatDict['permissions'])
# Set the permissions
except:
log.info(
'Failed to change log permissions; this may cause issues')
def configureLogger(loggerfilepath):
"""
Configuracion general del logger
"""
ch = logging.StreamHandler(sys.stdout)
ch.set_name("logmapper")
ch.setFormatter(
logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
root = logging.getLogger()
root.setLevel(logging.DEBUG)
for handler in root.handlers:
root.removeHandler(handler)
root.addHandler(ch)
fileHandler = logging.FileHandler(loggerfilepath)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fileHandler.setFormatter(formatter)
# root.addHandler(fileHandler)
rotateHandler = RotatingFileHandler(loggerfilepath,
maxBytes=10000000,
backupCount=2)
rotateHandler.set_name('rotateHandler')
rotateHandler.setFormatter(
logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
rotateHandler.setLevel(logging.INFO)
root.addHandler(rotateHandler)
def _setup_file_logging(logger, log_path):
# Create paths and files as needed.
log_path = Path(log_path)
os.makedirs(str(log_path.parent), mode=0x0755, exist_ok=True)
log_path.touch(mode=0o0664, exist_ok=True)
handler = RotatingFileHandler(str(log_path), maxBytes=1e7)
handler.rotator = _gzip_rotator
handler.namer = _gzip_namer
handler.setLevel(LOG_LEVEL_FILE)
formatter = CustomLoggingFormatter(LOG_FMT, DATE_FMT)
handler.setFormatter(formatter)
name = "File Handler"
handler.set_name(name)
if name not in [h.name for h in logger.handlers]:
logger.addHandler(handler)
logger.info("File logging initialized")
def get_logger(name) -> logging.Logger:
""" inits a logger and adds the handlers.
If the logger is already created doesn't adds new handlers
since those are set at interpreter level and already exists.
"""
# create logger
logger = logging.getLogger(name)
# set base logger level to DEBUG but fine tu the handlers
# for custom level
logger.setLevel(logging.DEBUG)
# create formatter fdor file handler (more explicit)
file_formatter = logging.Formatter(
'%(levelname)-8s [%(asctime)s] %(thread)d - %(name)s - %(message)s')
# formater for stream handler (less info)
stdout_formatter = logging.Formatter('%(levelname)s - %(message)s')
log_file = get_log_file() # Create the log file
# create console and file handler
# if not already created
if not logger.handlers:
# Send DEBUG to a rotating log file
# Limit the size to 1000000Bytes ~ 1MB
fh = RotatingFileHandler(log_file, maxBytes=1000000, backupCount=3)
fh.set_name('filehandler')
fh.setLevel('DEBUG')
fh.setFormatter(file_formatter)
logger.addHandler(fh)
# send INFO to the console (stdin)
ch = logging.StreamHandler(sys.stdout)
ch.set_name('streamhandler')
ch.setLevel('INFO')
ch.setFormatter(stdout_formatter)
logger.addHandler(ch)
return logger
# if there already handlers just return the logger
# since its already configured
else:
return logger
def start(start_file=None):
if start_file:
path = os.path.split(os.path.realpath(start_file))[0]
logging.debug("Setting directory to " + path)
docker_mode = False
else: # Use Docker setup
path = '/external'
logging.info("Bot running in Docker mode.")
logging.debug("Using Docker setup path, " + path)
docker_mode = True
try:
config_file_location = path + '/config/core-config.yaml'
with open(config_file_location, 'rb') as config_file:
config = yaml.safe_load(config_file)
selfbot_mode, token, debug = config['selfbot_mode'], config['token'], config['debug']
except Exception as e:
logging.error("Could not determine token /or selfbot mode.")
raise e
if selfbot_mode is True: # Explicit, for YAML 1.2 vs 1.1
client_type = discord.Client
logging.debug("Using standard client (selfbot enabled).")
else:
client_type = discord.AutoShardedClient
logging.debug("Using autosharded client (selfbot disabled).")
# Set debug logs
if debug is True:
log_file = '{}/temp/debug_logs.txt'.format(path)
if os.path.isfile(log_file):
shutil.copy2(log_file, '{}/temp/last_debug_logs.txt'.format(path))
file_handler = RotatingFileHandler(log_file, maxBytes=5000000, backupCount=5)
file_handler.set_name('jb_debug_file')
stream_handler = logging.StreamHandler()
stream_handler.set_name('jb_debug_stream')
logging.basicConfig(level=logging.DEBUG, handlers=[file_handler, stream_handler])
# Set regular logs
else:
log_file = '{}/temp/logs.txt'.format(path)
file_handler = RotatingFileHandler(log_file, maxBytes=5000000, backupCount=5)
file_handler.setFormatter(logging.Formatter(
'[%(filename)s] %(asctime)s %(levelname)s: %(message)s'))
file_handler.setLevel(logging.DEBUG)
file_handler.set_name('jb_log_file')
logger.addHandler(file_handler)
logger.setLevel(logging.DEBUG)
def safe_exit():
loop = asyncio.get_event_loop()
try: # From discord.py client.run
loop.run_until_complete(bot.logout())
pending = asyncio.Task.all_tasks()
gathered = asyncio.gather(*pending)
except Exception as e:
logger.error("Failed to log out. %s", e)
try:
gathered.cancel()
loop.run_until_complete(gathered)
gathered.exception()
except:
pass
logger.warn("Bot disconnected. Shutting down...")
bot.shutdown() # Calls sys.exit
def exception_handler(loop, context):
e = context.get('exception')
if e and e.__traceback__:
traceback_text = ''.join(traceback.format_tb(e.__traceback__))
else:
traceback_text = traceback.format_exc()
if not traceback_text:
traceback_text = '(No traceback available)'
error_message = '{}\n{}'.format(e, traceback_text)
logger.error("An uncaught exception occurred.\n%s", error_message)
with open(path + '/temp/error.txt', 'w') as error_file:
error_file.write(error_message)
logger.error("Error file written.")
if bot.is_closed():
safe_exit()
loop = asyncio.get_event_loop()
bot = get_new_bot(client_type, path, debug, docker_mode)
start_task = bot.start(token, bot=not selfbot_mode)
loop.set_exception_handler(exception_handler)
try:
loop.run_until_complete(start_task)
except KeyboardInterrupt:
logger.warn("Interrupted!")
safe_exit()
def log_gen(level='DEBUG',
logfile=None,
threads=False,
log_only=False,
email_level=None,
email_data={},
format=None):
"""
*+
* Name:
* log_gen
*
* Purpose:
* Generate a python logging instance
*
* Description:
* This method provides the mechanism to generate a python logger for
* recording structured information with levels from DEBUG to CRITICAL.
* Optional email escalation for submissions above a particular level
* is available.
*
* File output is via a rotating file handler that will archive the log
* when it reaches 5MB in size. The output format of the log entry is:
*
* Day nn Month hr:mm:ss yyyy @module.<function>() [level] [thread_id] : message
*
* Arguments:
* level ['DEBUG']
* The minimum reporting level to output
* logfile [None]
* String to output logfile if required
* threads [False]
* Will multiple threads be generating log entries?
* log_only [False]
* Only output to the logfile (do not output to stdout)
* email_level [None]
* Define minimum loglevel for email escalation
* email_data [{}]
* Python dictionary containing information needed for email messaging. Keys:
* 'FROM' : The email address of the author
* 'TO' : The target email address
* 'SUBJECT' : Subject line for the email
* 'BUFFER' : Number of lines before the buffer is flushed (ie, send email)
*
* Returned values:
* Instance of <logging.RootLogger>
*
* Notes:
* None
*
* Dependencies:
* Python core
*
* Authors:
* David Murphy (CASU, IoA)
*
* Copyright:
* Copyright (C) 2017-2018 Cambridge Astronomy Survey Unit.
* All Rights Reserved.
*
+*
"""
import sys
a = 1
import logging
from logger import ColourFormatter
if level not in ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']:
#print "defined level '%s' not recognised. Setting to DEBUG" %(level)
level = 'DEBUG'
log = logging.getLogger()
custom_format = 'auto'
if not len(log.handlers):
log.setLevel(level)
if threads:
formatter = logging.Formatter(
'%(asctime)s @%(module)s.%(funcName)s() [%(levelname)s] [%(threadName)s] : %(message)s',
datefmt="%a %d %b %H:%M:%S %Y")
else:
formatter = logging.Formatter(
'%(asctime)s @%(module)s.%(funcName)s() [%(levelname)s] : %(message)s',
datefmt="%a %d %b %H:%M:%S %Y")
if format:
formatter = logging.Formatter(format)
custom_format = format
if email_level != None:
from logger import SMTPBufferHandler
MAILHOST = 'smtp.ast.cam.ac.uk'
try:
FROM = email_data['FROM']
except KeyError:
FROM = '*****@*****.**'
try:
TO = email_data['TO']
except:
TO = '*****@*****.**'
try:
SUBJECT = email_data['SUBJECT']
except:
SUBJECT = 'A critical message from your server'
try:
buffer_size = email_data['BUFFER']
except:
buffer_size = 1
eh = SMTPBufferHandler(MAILHOST, FROM, TO, SUBJECT, buffer_size)
eh.setLevel('CRITICAL')
eh.setFormatter(formatter)
eh.set_name('email_stream')
log.addHandler(eh)
if (not log_only) or (not logfile):
ch = logging.StreamHandler(sys.stdout)
ch.setLevel(level)
ch.setFormatter(formatter)
ch.setFormatter(
ColourFormatter(threads=threads, format=custom_format))
ch.set_name('stdout')
log.addHandler(ch)
if logfile:
from logging.handlers import RotatingFileHandler
fh = RotatingFileHandler(logfile, maxBytes=5242880, backupCount=20)
# fh = logging.FileHandler(logfile)
fh.setLevel(level)
fh.setFormatter(formatter)
fh.set_name('log_file')
log.addHandler(fh)
return log
