def doRollover(self):
def rename(f,t):
if not os.path.exists(f):
return
if os.path.exists(t):
os.remove(t)
os.rename(f,t)
t = self.rolloverAt - self.interval
timeTuple = localtime(t)
base = self.baseFilename + "." + strftime(self.suffix, timeTuple)
if os.path.exists( base ):
# increment the suffix number of older logfiles, since TimedRotatingFileHandler
# will overwrite "base"
for b in xrange( self.fileCount, -1, -1 ):
if b == 0:
sfn = base
else:
sfn = base + "." + str(b)
dfn = base + "." + str(b+1)
rename( sfn, dfn )
self.fileCount += 1
else:
self.fileCount = 1
TimedRotatingFileHandler.doRollover(self)
def setup_logging():
if not os.path.exists('logs'):
os.makedirs('logs')
try:
DEFAULT_LOGGING_FORMAT = "[%(asctime)s %(levelname)-8s %(filename)-15s:%(lineno)3s - %(funcName)-20s ] %(message)s"
# logging.getLogger('discord')
# logging.getLogger('discord.http')
logger = logging.getLogger('root')
logging.basicConfig(format=DEFAULT_LOGGING_FORMAT)
if config.debug_mode:
logger.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.INFO)
loggerFileHandler = TimedRotatingFileHandler('logs/rcomp.log',
when='midnight',
backupCount=1000)
loggerFileHandler.setFormatter(
logging.Formatter(DEFAULT_LOGGING_FORMAT))
loggerFileHandler.doRollover()
logger.addHandler(loggerFileHandler)
yield
finally:
# __exit__
handlers = logger.handlers[:]
for hdlr in handlers:
hdlr.close()
logger.removeHandler(hdlr)
def doRollover(self):
def rename(f, t):
if not os.path.exists(f):
return
if os.path.exists(t):
os.remove(t)
os.rename(f, t)
t = self.rolloverAt - self.interval
timeTuple = localtime(t)
base = self.baseFilename + "." + strftime(self.suffix, timeTuple)
if os.path.exists(base):
# increment the suffix number of older logfiles, since TimedRotatingFileHandler
# will overwrite "base"
for b in xrange(self.fileCount, -1, -1):
if b == 0:
sfn = base
else:
sfn = base + "." + str(b)
dfn = base + "." + str(b + 1)
rename(sfn, dfn)
self.fileCount += 1
else:
self.fileCount = 1
TimedRotatingFileHandler.doRollover(self)
def initFileLogging(outputFileName, defaultLevel=logging.INFO, formatStr="%(asctime)s %(levelname)s %(message)s"):
logger.setLevel(defaultLevel)
fileHandle = TimedRotatingFileHandler(outputFileName, when="H", interval=1, backupCount=MAX_BACKUP_COUNT)
formatter = logging.Formatter(formatStr)
fileHandle.setLevel(defaultLevel)
fileHandle.setFormatter(formatter)
logger.addHandler(fileHandle)
fileHandle.doRollover()
def doRollover(self):
XTimedRotatingFileHandler.lock.acquire()
try:
if self.shouldRollover(None):
TimedRotatingFileHandler.doRollover(self)
self.processRolloverAt()
finally:
XTimedRotatingFileHandler.lock.release()
def _configLogs(self, globalConfig):
ch = logging.StreamHandler()
ch.setFormatter(logging.Formatter(globalConfig.get('global', 'log-format')))
fh = TimedRotatingFileHandler(os.path.join(globalConfig.get('global', 'log-dir'), 'cnb-trivia.log'), backupCount=0, when='d', interval=1)
fh.setFormatter(logging.Formatter(globalConfig.get('global', 'log-format')))
fh.doRollover()
logLevel = logging.DEBUG
self.log.addHandler(ch)
self.log.addHandler(fh)
self.log.setLevel(logLevel)
def initFileLogging(outputFileName, defaultLevel=logging.INFO,
formatStr = '%(asctime)s %(levelname)s %(message)s'):
logger.setLevel(defaultLevel)
fileHandle = TimedRotatingFileHandler(outputFileName,
when='H',
interval=1,
backupCount=MAX_BACKUP_COUNT)
formatter = logging.Formatter(formatStr)
fileHandle.setLevel(defaultLevel)
fileHandle.setFormatter(formatter)
logger.addHandler(fileHandle)
fileHandle.doRollover()
def doRollover(self):
print 'Html log: rollover'
# Calculate the new name of this file using the same code as superclass:
# /Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/logging/handlers.py
t = self.rolloverAt - self.interval
timeTuple = time.localtime(t)
dfn = self.baseFilename + "." + time.strftime(self.suffix, timeTuple)
self.footer()
TimedRotatingFileHandler.doRollover(self)
rotated_filename = os.path.basename(dfn)
self.header(rotated_filename)
def initFileLogging(outputFileName, defaultLevel=logging.INFO,
formatStr = '%(asctime)s %(levelname)s %(message)s'):
logger.setLevel(defaultLevel)
fileHandle = TimedRotatingFileHandler(outputFileName,
when='H',
interval=1,
backupCount=MAX_BACKUP_COUNT)
formatter = logging.Formatter(formatStr)
fileHandle.setLevel(defaultLevel)
fileHandle.setFormatter(formatter)
logger.addHandler(fileHandle)
if sys.hexversion < 0x020700F0: # version less that 2.7
fileHandle.doRollover()
return fileHandle
def init_logging(log_path, level):
log_file = log_path + 'log.txt'
log_format = '%(asctime)s - [%(levelname)s] %(name)s: %(message)s'
logging.basicConfig(level=level, format=log_format)
logging.getLogger('requests').setLevel(logging.ERROR)
logging.getLogger('urllib3').setLevel(logging.ERROR)
logger = logging.getLogger()
rollover = path.isfile(log_file)
handler = TimedRotatingFileHandler(filename=log_file,
backupCount=5,
when='d',
interval=1)
handler.setFormatter(logging.Formatter(log_format))
logger.addHandler(handler)
if rollover:
handler.doRollover()
def _configLogs(self, globalConfig):
ch = logging.StreamHandler()
ch.setFormatter(
logging.Formatter(globalConfig.get('global', 'log-format')))
fh = TimedRotatingFileHandler(os.path.join(
globalConfig.get('global', 'log-dir'), 'cnb-trivia.log'),
backupCount=0,
when='d',
interval=1)
fh.setFormatter(
logging.Formatter(globalConfig.get('global', 'log-format')))
fh.doRollover()
logLevel = logging.DEBUG
self.log.addHandler(ch)
self.log.addHandler(fh)
self.log.setLevel(logLevel)
def _initLogging(self):
if self._logfile is None:
return
from logging.handlers import TimedRotatingFileHandler
log = logging.getLogger()
formatter = logging.Formatter("%(asctime)s - %(name)s "
"- %(levelname)s - %(message)s")
h = TimedRotatingFileHandler(self._logfile, when="midnight",
backupCount=self._logfilecount)
h.doRollover()
if self._verbose:
log.setLevel(logging.DEBUG)
else:
log.setLevel(logging.INFO)
h.setFormatter(formatter)
log.addHandler(h)
def doRollover(self):
#rotate
with open(self.baseFilename + '.lock', 'a') as f:
try:
fcntl.flock(f, fcntl.LOCK_EX)
if not os.path.exists(self.baseFilename):
f_new = open(self.baseFilename, 'w')
f_new.close()
stat = os.stat(self.baseFilename)
if self.dev != stat.st_dev or self.ino != stat.st_ino:
# stream is not the same.Log file must be rotated already.
self.get_new_file()
self.cumpute_next_time()
else:
TimedRotatingFileHandler.doRollover(self)
self.get_new_file()
except:
pass
finally:
fcntl.flock(f, fcntl.LOCK_UN)
def doRollover(self):
return TimedRotatingFileHandler.doRollover(self)
def doRollover(self):
TimedRotatingFileHandler.doRollover(self)
file_paths = self.get_uncompressed_logs()
for file_path in file_paths:
self.compress(file_path)
os.remove(file_path)
def doRollover(self):
TimedRotatingFileHandler.doRollover(self)
# redirect stderr to log file
os.dup2(self.stream.fileno(), sys.stderr.fileno())
def doRollover(self):
TimedRotatingFileHandler.doRollover(self)
gid = grp.getgrnam('docker').gr_gid
os.chown(self.baseFilename, 0, gid)
os.chmod(self.baseFilename, 0o664)
def doRollover(self):
TimedRotatingFileHandler.doRollover(self)
gid = grp.getgrnam('docker').gr_gid
os.chown(self.baseFilename, -1, gid)
os.chmod(self.baseFilename, 0o664)
def doRollover(self):
TimedRotatingFileHandler.doRollover(self)
self.rolloverAt = self.get_next_rollover_at()
def doRollover(self):
TimedRotatingFileHandler.doRollover(self)
# redirect stderr to log file
os.dup2(self.stream.fileno(), sys.stderr.fileno())
import jira_model
import get_jira_worklog
import argparse
import logging
import send_email
from logging.handlers import TimedRotatingFileHandler
log_file = "../logs/jira.log"
logger = logging.getLogger("jiraLogger")
logger.setLevel(logging.INFO)
handler = TimedRotatingFileHandler(log_file,
when="H",
interval=1,
backupCount=24)
logger.addHandler(handler)
handler.doRollover()
parser = argparse.ArgumentParser(__file__)
parser.add_argument('-t',
dest='hours',
help='Time in hours to retrieve',
type=int)
parser.add_argument('-i', dest='issue_key', help='Jira issue key', type=str)
parser.add_argument('-s',
dest='skip_update',
help='Skip user update',
action='store_true')
parser.add_argument('-e',
dest='email_only',
help='Send emails only',
action='store_true')
def doRollover(self):
TimedRotatingFileHandler.doRollover(self)
if os.stat(self.baseFilename).st_size <= 0:
os.remove(self.baseFilename)
def doRollover(self):
# Just chmod the file
TimedRotatingFileHandler.doRollover(self)
_make_writable(self.baseFilename)
def setup_logging(config=None, debug_mode=False):
"""
Configure logging based on config data and debug mode status.
"""
log_path = current_path + '/logs'
log_ext = '.log'
log_modes = config["log_mode"]
log_prefix = log_path + '/output'
single_log_path = log_prefix + log_ext
log_format = "%(asctime)s [%(levelname)s] %(message)s"
log_date_style = "%m/%d/%Y %I:%M:%S %p"
log_format_style = "%Y-%m-%d_%H-%M-%S"
start_timestamp = datetime.now().strftime(log_format_style)
# Adjust log level depending on mode
log_level = logging.INFO
if debug_mode:
log_level = logging.DEBUG
# Setup Main Logger and Formatting
root_logger = logging.getLogger("DRPLogger")
root_logger.setLevel(log_level)
log_formatter = logging.Formatter(log_format, log_date_style)
color_formatter = log_formatter
# Setup handlers depending on config options
if "full" in log_modes or "v1" in log_modes or "console" in log_modes:
console_handler = logging.StreamHandler(stream=sys.stdout)
if ("full" in log_modes or "color" in log_modes
) and "no-color" not in log_modes and "plain" not in log_modes:
# Import Optional Colored Formatter, if able
try:
from colored_log import ColoredFormatter
color_formatter = ColoredFormatter(log_format, log_date_style)
console_handler.setFormatter(color_formatter)
except (ModuleNotFoundError, TypeError):
pass
else:
console_handler.setFormatter(log_formatter)
console_handler.setLevel(log_level)
root_logger.addHandler(console_handler)
if "full" in log_modes or "multiple_files" in log_modes or "files" in log_modes:
if not os.path.exists(log_path):
os.makedirs(log_path)
staged_handler = TimedRotatingFileHandler(single_log_path,
when="midnight",
interval=1)
staged_handler.suffix = start_timestamp
staged_handler.namer = lambda name: name.replace(log_ext, "") + log_ext
should_roll_over = os.path.isfile(single_log_path)
if should_roll_over: # log already exists, roll over!
staged_handler.doRollover()
staged_handler.setFormatter(log_formatter)
staged_handler.setLevel(log_level)
root_logger.addHandler(staged_handler)
elif "v1" in log_modes or "single_file" in log_modes or "file" in log_modes:
file_handler = logging.FileHandler(single_log_path, mode='w')
file_handler.setFormatter(log_formatter)
file_handler.setLevel(log_level)
root_logger.addHandler(file_handler)
return root_logger
def doRollover(self):
TimedRotatingFileHandler.doRollover(self)
os.dup2(self.stream.fileno(), sys.stderr.fileno())
