def __init__(self, filename, mode='a', maxBytes=0, backupCount=0, encoding=None, delay=0):
"""
Open the specified file and use it as the stream for logging.
By default, the file grows indefinitely. You can specify particular
values of maxBytes and backupCount to allow the file to rollover at
a predetermined size.
Rollover occurs whenever the current log file is nearly maxBytes in
length. If backupCount is >= 1, the system will successively create
new files with the same pathname as the base file, but with extensions
".1", ".2" etc. appended to it. For example, with a backupCount of 5
and a base file name of "app.log", you would get "app.log",
"app.log.1", "app.log.2", ... through to "app.log.5". The file being
written to is always "app.log" - when it gets filled up, it is closed
and renamed to "app.log.1", and if files "app.log.1", "app.log.2" etc.
exist, then they are renamed to "app.log.2", "app.log.3" etc.
respectively.
If maxBytes is zero, rollover never occurs.
"""
# If rotation/rollover is wanted, it doesn't make sense to use another
# mode. If for example 'w' were specified, then if there were multiple
# runs of the calling application, the logs from previous runs would be
# lost if the 'w' is respected, because the log file would be truncated
# on each run.
if maxBytes > 0:
mode = 'a'
BaseRotatingHandler.__init__(self, filename, mode, encoding, delay)
self.maxBytes = maxBytes
self.backupCount = backupCount
self.baseFilename = self.baseFilename.split('+')[0]+'+'+datetime.datetime.now().strftime('%Y-%m-%d__%H-%M-%S-%f')+'.txt'
def __init__(self, filename, when='h', interval=1, backupCount=0, encoding=None, delay=False, utc=False):
BaseRotatingHandler.__init__(self, filename, 'a', encoding, delay)
self.when = when.upper()
self.backupCount = backupCount
self.utc = utc
if self.when == 'H':
self.interval = 60 * 60 # one hour
self.suffix = "%Y-%m-%d_%H"
self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}$"
elif self.when == 'MIDNIGHT':
self.interval = 60 * 60 * 24 # one day
self.suffix = "%Y-%m-%d"
self.extMatch = r"^\d{4}-\d{2}-\d{2}$"
elif self.when.startswith('W'):
self.interval = 60 * 60 * 24 * 7 # one week
if len(self.when) != 2:
raise ValueError("You must specify a day for weekly rollover from 0 to 6 (0 is Monday): %s" % self.when)
if self.when[1] < '0' or self.when[1] > '6':
raise ValueError("Invalid day specified for weekly rollover: %s" % self.when)
self.dayOfWeek = int(self.when[1])
self.suffix = "%Y-%m-%d"
self.extMatch = r"^\d{4}-\d{2}-\d{2}$"
else:
raise ValueError("Invalid rollover interval specified: %s" % self.when)
self.extMatch = re.compile(self.extMatch)
self.interval = self.interval * interval # multiply by units requested
if os.path.exists(filename):
t = os.stat(filename)[ST_MTIME]
else:
t = int(time.time())
self.rolloverAt = self.computeRollover(t)
def __init__(self, filename, maxbytes=2*1024, mode='a', encoding=None, delay=0):
self.mode = mode
self.index = 0
self.maxBytes = maxbytes
self.createdate = datetime.datetime.now().strftime("%Y%m%d")
if DEBUG: self.createdate = DATESTR
BaseRotatingHandler.__init__(self, filename, mode, encoding, delay)
def __init__(self, filename, mode='a', maxBytes=0, backupCount=0,
encoding=None, debug=True, supress_abs_warn=False):
try:
BaseRotatingHandler.__init__(self, filename, mode, encoding)
except TypeError: # Due to a different logging release without encoding support (Python 2.4.1 and earlier?)
BaseRotatingHandler.__init__(self, filename, mode)
self.encoding = encoding
self._rotateFailed = False
self.maxBytes = maxBytes
self.backupCount = backupCount
# Prevent multiple extensions on the lock file (Only handles the normal "*.log" case.)
lock_dir = os.path.join(os.path.dirname(filename), '.lock')
if not os.path.isdir(lock_dir):
create_dir(lock_dir)
log_filename = os.path.basename(filename)
if log_filename.endswith(".log"):
lock_file = os.path.join(lock_dir, log_filename[:-4])
else:
lock_file = os.path.join(lock_dir, log_filename)
self.stream_lock = open(lock_file + ".lock", "w")
# For debug mode, swap out the "_degrade()" method with a more a verbose one.
if debug:
self._degrade = self._degrade_debug
def __init__(self, filename, mode='w', when='H', prefix=True, utc=True, encoding=None, delay=0):
"""
Open a file and use it as a stream for logging.
Open a new file at specified times.
By default, the time is used as a prefix on the output filename.
Parameters
----------
Returns
-------
"""
BaseRotatingHandler.__init__(self, filename, mode, encoding, delay)
self.when = when
self.prefix = prefix
self.utc = utc
if self.when == 'S':
self.interval = 1
self.tstring = '%Y%m%d_%H%M%S' #TODO allow optional tstr arg?
elif self.when == 'M':
self.interval = 60;
self.tstring = '%Y%m%d_%H%M'
elif self.when == 'H':
self.interval = 60 * 60;
self.tstring = '%Y%m%d_%H%M' # still keep minutes
elif self.when == 'D':
self.interval = 24 * 60 * 60;
self.tstring = '%Y%M%D'
else:
raise ValueError("Invalid rollover interval specified: %s" % self.when)
self.openNewFile(time.time())
def __init__(self, filename, when, encoding=None, delay=0):
self.when = string.upper(when)
self.fname_pat = filename
self.mock_dt = None
self.computeNextRollover()
BaseRotatingHandler.__init__(self, self.filename, 'a', encoding, delay)
def __init__(self, pathformat="logs/%Y/%m/%Y-%m-%d.log", utc=False, encoding=None, delay=False):
self.path_format = pathformat
self.utc = utc
current_time = self._get_time()
current_file = self._format_time(current_time)
self._current_day = self._get_days_since_epoch(current_time)
self._create_dirs(resource_filename('logs', current_file))
BaseRotatingHandler.__init__(self, filename=resource_filename('logs', current_file), mode="a",
encoding=encoding, delay=delay)
def __init__(self, filename, mode='a', max_bytes=256, backup_count=5, encoding=None, cmp_type='gzip', cmp_level=9, suffixes='gz'):
if max_bytes > 0:
mode = 'a'
BaseRotatingHandler.__init__(self, filename, mode, encoding)
self.filename = filename
self.backup_count = backup_count
self.max_bytes = max_bytes
self.cmp_type = cmp_type
self.cmp_level = cmp_level
self.suffixes = suffixes
def release(self):
""" Release file and thread locks.
"""
try:
if self.stream_lock and not self.stream_lock.closed:
unlock(self.stream_lock)
except Exception:
pass
finally:
# release thread lock
BaseRotatingHandler.release(self)
def __init__(self, prefix_name, backup_count=0, encoding=None, delay=False, utc=False):
self.suffix_name_ = "%Y%m%d.log"
self.prefix_name_= prefix_name
self.utc_ = utc
cur_file_name = self._current_log_filename()
self.backup_count_ = backup_count
BaseRotatingHandler.__init__(self, cur_file_name, 'a', encoding, delay)
self.interval_ = 60 * 60 * 24 # one day
self.ext_match_ = re.compile(r"^\d{4}\d{2}\d{2}$")
self.rollover_at_ = self.compute_rollover()
def __init__(self, filename, mode='a', maxBytes=0, backupCount=0,
encoding=None, debug=True, delay=0):
"""
Open the specified file and use it as the stream for logging.
By default, the file grows indefinitely. You can specify particular
values of maxBytes and backupCount to allow the file to rollover at
a predetermined size.
Rollover occurs whenever the current log file is nearly maxBytes in
length. If backupCount is >= 1, the system will successively create
new files with the same pathname as the base file, but with extensions
".1", ".2" etc. appended to it. For example, with a backupCount of 5
and a base file name of "app.log", you would get "app.log",
"app.log.1", "app.log.2", ... through to "app.log.5". The file being
written to is always "app.log" - when it gets filled up, it is closed
and renamed to "app.log.1", and if files "app.log.1", "app.log.2" etc.
exist, then they are renamed to "app.log.2", "app.log.3" etc.
respectively.
If maxBytes is zero, rollover never occurs.
On Windows, it is not possible to rename a file that is currently opened
by another process. This means that it is not possible to rotate the
log files if multiple processes is using the same log file. In this
case, the current log file will continue to grow until the rotation can
be completed successfully. In order for rotation to be possible, all of
the other processes need to close the file first. A mechanism, called
"degraded" mode, has been created for this scenario. In degraded mode,
the log file is closed after each log message is written. So once all
processes have entered degraded mode, the net rotation attempt should
be successful and then normal logging can be resumed. Using the 'delay'
parameter may help reduce contention in some usage patterns.
This log handler assumes that all concurrent processes logging to a
single file will are using only this class, and that the exact same
parameters are provided to each instance of this class. If, for
example, two different processes are using this class, but with
different values for 'maxBytes' or 'backupCount', then odd behavior is
expected. The same is true if this class is used by one application, but
the RotatingFileHandler is used by another.
"""
# Absolute file name handling done by FileHandler since Python 2.5
BaseRotatingHandler.__init__(self, filename, mode, encoding, delay)
self.delay = delay
self._rotateFailed = False
self.maxBytes = maxBytes
self.backupCount = backupCount
self._open_lockfile()
# For debug mode, swap out the "_degrade()" method with a more a verbose one.
if debug:
self._degrade = self._degrade_debug
def __init__(self, filename, maxDays=1, minDays=0, maxMBytes=10, backupCount=5, compression=None):
"""
Initialize the Handler. We assume the following:
1. Interval is in days
2. No special encoding
3. No delays are set
4. Timestamps are not in UTC
@type filename: string
@param filename: The full path of the log file
@type interval: int
@param interval: Number of days before file rotation
@type maxMBytes: int
@param maxMBytes: Maximum size of the logfile in MB before file rotation
@type backupCount: int
@param backupCount: Number of backups to keep
"""
# Make dirs if logging directory does not exist
if not os.path.exists(os.path.dirname(filename)):
os.makedirs(os.path.dirname(filename))
self.compression = ''
try:
if compression.lower() in COMPRESSION_SUPPORTED:
self.compression = compression.lower()
except AttributeError:
pass
# bz2 compression can be implementes with encoding='bz2-codec' in BaseRotatingHandler
mode = 'a'
BaseRotatingHandler.__init__(self, filename, mode, encoding=None)
self.backupCount = backupCount
self.maxBytes = maxMBytes * 1024.0 * 1024.0 # Convert the MB to bytes as needed by the base class
self.min_lifetime = minDays * 24 * 60 * 60 # Convert min days to seconds
self.interval = maxDays * 24 * 60 * 60 # Convert max days (interval) to seconds
# We are enforcing a date/time format for rotated log files to include
# year, month, day, hours, and minutes. The hours and minutes are to
# preserve multiple rotations in a single day.
self.suffix = "%Y-%m-%d_%H-%M"
self.extMatch = re.compile(r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}(\.gz|\.zip)?$")
if os.path.exists(filename):
begin_interval_time = os.stat(filename)[stat.ST_MTIME]
else:
begin_interval_time = int(time.time())
self.rolloverAt = begin_interval_time + self.interval
def __init__(self, filename, delay=0, symlink=True, prologue=None, epilogue=None, rollover=None):
self.prefix = filename + "-"
self.suffix = "%Y-%m-%d"
self.prologue = prologue
self.epilogue = epilogue
self.rollover = rollover
self.symlink = symlink
self.rolloverAt = self.computeRollover(int(time.time()))
if symlink:
self._symlinkPointToToday(filename)
BaseRotatingHandler.__init__(self, filename, "a", None, delay)
# print "Will rollover at %d, %d seconds from now" % (self.rolloverAt, self.rolloverAt - currentTime)
if self.prologue:
self.stream.write(self.prologue % self._getParameter())
def __init__(self, filename, hour=8, minute=0, backupCount=0, encoding=None, delay=False, utc=False):
BaseRotatingShitHandler.__init__(self, filename, 'a', encoding, delay)
self.delay = delay
self.backupCount = backupCount
self.utc = utc
self.interval = 60 * 60 * 24
self.suffix = "%Y-%m-%d"
self.extMatch = r"^\d{4}-\d{2}-\d{2}$"
self.extMatch = re.compile(self.extMatch)
t = int(time.mktime(datetime.datetime.now(pytz.timezone("Europe/Berlin")).replace(hour=hour, minute=minute, second=0).timetuple()))
if datetime.datetime.now(pytz.timezone("Europe/Berlin")).hour < hour or (datetime.datetime.now(pytz.timezone("Europe/Berlin")).hour==hour and datetime.datetime.now(pytz.timezone("Europe/Berlin")).minute < minute):
self.rolloverAt = self.computeRollover(t-self.interval)
else:
self.rolloverAt = self.computeRollover(t)
def __init__(self,
pathformat="%Y/%m/%Y-%m-%d.log", utc=False,
encoding=None, delay=False):
self.pathformat = pathformat
self.utc = utc
# Placeholder function for the info function of the
# logging module.
self.logging_writeinfo = lambda *args: None
current_time = self._get_time()
current_file = self._format_time(current_time)
self._current_day = self._get_days_since_epoch(current_time)
self._create_dirs(os.path.abspath(current_file))
BaseRotatingHandler.__init__(self,
filename=current_file, mode="a",
encoding=encoding, delay=delay)
def __init__(self, filename, mode='a',
timestring_format="%Y%m%d_%H%M%S", prefix=True, encoding=None):
'''Open the specified file and use it as the stream for logging.
File grows indefinitely, until rollover is called.
A rollover will close the stream; rename the file to a new name,
with a prefix or suffix (prefix if prameter prefix=True)
to the filename of the current date and time, in the format specified
by timestring_format; and open a fresh log file.
For example, with a base file name of "app.log", and other arguments
as default, a rolled-over logfile might have a name of
"20090610_234620.app.log".
The file being written to is always "app.log".
timestring_format is a format string, as described for time.strftime().
'''
BaseRotatingHandler.__init__(self, filename, mode, encoding)
self.timestring_format = timestring_format
self.prefix = prefix
def __init__(self, filename, mode='a', maxBytes=0, encoding=None,
debug=True, delay=0):
"""
Open the specified file and use it as the stream for logging.
By default, the file grows indefinitely. You can specify particular
values of maxBytes to allow the file to rollover at a predetermined
size.
Rollover occurs whenever the current log file is nearly maxBytes in
length. Old files are renamed based on timestamps.
If maxBytes is zero, rollover never occurs.
"""
# Absolute file name handling done by FileHandler since Python 2.5
BaseRotatingHandler.__init__(self, filename, mode, encoding, delay)
self.delay = delay
self._rotateFailed = False
self.maxBytes = maxBytes
self._open_lockfile()
# For debug mode, swap out the "_degrade()" method with a more a verbose one.
if debug:
self._degrade = self._degrade_debug
def acquire(self):
""" Acquire thread and file locks.
Copid from ConcurrentRotatingFileHandler
"""
# handle thread lock
BaseRotatingHandler.acquire(self)
# Issue a file lock. (This is inefficient for multiple active threads
# within a single process. But if you're worried about high-performance,
# you probably aren't using this log handler.)
if self.stream_lock:
# If stream_lock=None, then assume close() was called or something
# else weird and ignore all file-level locks.
if self.stream_lock.closed:
# Daemonization can close all open file descriptors, see
# https://bugzilla.redhat.com/show_bug.cgi?id=952929
# Try opening the lock file again. Should we warn() here?!?
try:
self._openLockFile()
except Exception:
# Don't try to open the stream lock again
self.stream_lock = None
return
lock(self.stream_lock, LOCK_EX)
def __init__(self,
filename,
mode='a',
maxBytes=0,
backupCount=0,
encoding=None,
debug=True):
"""
Open the specified file and use it as the stream for logging.
By default, the file grows indefinitely. You can specify particular
values of maxBytes and backupCount to allow the file to rollover at
a predetermined size.
Rollover occurs whenever the current log file is nearly maxBytes in
length. If backupCount is >= 1, the system will successively create
new files with the same pathname as the base file, but with extensions
".1", ".2" etc. appended to it. For example, with a backupCount of 5
and a base file name of "app.log", you would get "app.log",
"app.log.1", "app.log.2", ... through to "app.log.5". The file being
written to is always "app.log" - when it gets filled up, it is closed
and renamed to "app.log.1", and if files "app.log.1", "app.log.2" etc.
exist, then they are renamed to "app.log.2", "app.log.3" etc.
respectively.
If maxBytes is zero, rollover never occurs.
On Windows, it is not possible to rename a file that is currently opened
by another process. This means that it is not possible to rotate the
log files if multiple processes is using the same log file. In this
case, the current log file will continue to grow until the rotation can
be completed successfully. In order for rotation to be possible, all of
the other processes need to close the file first. A mechanism, called
"degraded" mode, has been created for this scenario. In degraded mode,
the log file is closed after each log message is written. So once all
processes have entered degraded mode, the next rotate log attempt should
be successful and then normal logging can be resumed.
This log handler assumes that all concurrent processes logging to a
single file will are using only this class, and that the exact same
parameters are provided to each instance of this class. If, for
example, two different processes are using this class, but with
different values for 'maxBytes' or 'backupCount', then odd behavior is
expected. The same is true if this class is used by one application, but
the RotatingFileHandler is used by another.
NOTE: You should always provide 'filename' as an absolute path, since
this class will need to re-open the file during rotation. If your
application call os.chdir() then subsequent log files could be created
in the wrong directory.
"""
# if the given filename contains no path, we make an absolute path
if not os.path.isabs(filename):
if FORCE_ABSOLUTE_PATH or \
not os.path.split(filename)[0]:
filename = os.path.abspath(filename)
try:
BaseRotatingHandler.__init__(self, filename, mode, encoding)
except TypeError: # Due to a different logging release without encoding support (Python 2.4.1 and earlier?)
BaseRotatingHandler.__init__(self, filename, mode)
self.encoding = encoding
self._rotateFailed = False
self.maxBytes = maxBytes
self.backupCount = backupCount
# Prevent multiple extensions on the lock file (Only handles the normal "*.log" case.)
if filename.endswith(".log"):
lock_file = filename[:-4]
else:
lock_file = filename
self.stream_lock = open(lock_file + ".lock", "w")
# For debug mode, swap out the "_degrade()" method with a more a verbose one.
if debug:
self._degrade = self._degrade_debug
def __init__(self, base_filename):
self.base_filename = base_filename
self.date_val = self.date_value
BaseRotatingHandler.__init__(self, self.date_filename, 'a', None, 0)
def emit(self, record):
"""PiCloud: Support for disabling"""
if not self._disabled:
BaseRotatingHandler.emit(self, record)
def __init__(self,
filename,
when='h',
interval=1,
backupCount=0,
encoding=None,
delay=False,
utc=False):
BaseRotatingHandler.__init__(self, filename, 'a', encoding, delay)
self.when = when.upper()
self.backupCount = backupCount
self.utc = utc
# Calculate the real rollover interval, which is just the number of
# seconds between rollovers. Also set the filename suffix used when
# a rollover occurs. Current 'when' events supported:
# S - Seconds
# M - Minutes
# H - Hours
# D - Days
# midnight - roll over at midnight
# W{0-6} - roll over on a certain day; 0 - Monday
#
# Case of the 'when' specifier is not important; lower or upper case
# will work.
if self.when == 'S':
self.interval = 1 # one second
self.suffix = "%Y-%m-%d_%H-%M-%S"
self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}$"
elif self.when == 'M':
self.interval = 60 # one minute
self.suffix = "%Y-%m-%d_%H-%M"
self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}$"
elif self.when == 'H':
self.interval = 60 * 60 # one hour
self.suffix = "%Y-%m-%d_%H"
self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}$"
elif self.when == 'D' or self.when == 'MIDNIGHT':
self.interval = 60 * 60 * 24 # one day
self.suffix = "%Y-%m-%d"
self.extMatch = r"^\d{4}-\d{2}-\d{2}$"
elif self.when.startswith('W'):
self.interval = 60 * 60 * 24 * 7 # one week
if len(self.when) != 2:
raise ValueError(
"You must specify a day for weekly rollover from 0 to 6 (0 is Monday): %s"
% self.when)
if self.when[1] < '0' or self.when[1] > '6':
raise ValueError(
"Invalid day specified for weekly rollover: %s" %
self.when)
self.dayOfWeek = int(self.when[1])
self.suffix = "%Y-%m-%d"
self.extMatch = r"^\d{4}-\d{2}-\d{2}$"
else:
raise ValueError("Invalid rollover interval specified: %s" %
self.when)
self.extMatch = re.compile(self.extMatch)
self.interval = self.interval * interval # multiply by units requested
if os.path.exists(filename):
t = os.stat(filename)[ST_MTIME]
else:
t = int(time.time())
self.rolloverAt = self.computeRollover(t)
def __init__(self, filename, encoding=None, delay=False, utc=False, **kwargs):
self.utc = utc
self.suffix = "%Y-%m-%d"
self.baseFilename = filename
self.currentFileName = self._compute_fn()
BaseRotatingHandler.__init__(self, filename, 'a', encoding, delay)
def __init__(
self,
filename,
mode="a",
maxBytes=0,
backupCount=0,
encoding=None,
debug=True,
supress_abs_warn=False,
):
"""
Open the specified file and use it as the stream for logging.
By default, the file grows indefinitely. You can specify particular
values of maxBytes and backupCount to allow the file to rollover at
a predetermined size.
Rollover occurs whenever the current log file is nearly maxBytes in
length. If backupCount is >= 1, the system will successively create
new files with the same pathname as the base file, but with extensions
".1", ".2" etc. appended to it. For example, with a backupCount of 5
and a base file name of "app.log", you would get "app.log",
"app.log.1", "app.log.2", ... through to "app.log.5". The file being
written to is always "app.log" - when it gets filled up, it is closed
and renamed to "app.log.1", and if files "app.log.1", "app.log.2" etc.
exist, then they are renamed to "app.log.2", "app.log.3" etc.
respectively.
If maxBytes is zero, rollover never occurs.
On Windows, it is not possible to rename a file that is currently opened
by another process. This means that it is not possible to rotate the
log files if multiple processes is using the same log file. In this
case, the current log file will continue to grow until the rotation can
be completed successfully. In order for rotation to be possible, all of
the other processes need to close the file first. A mechanism, called
"degraded" mode, has been created for this scenario. In degraded mode,
the log file is closed after each log message is written. So once all
processes have entered degraded mode, the next rotate log attempt should
be successful and then normal logging can be resumed.
This log handler assumes that all concurrent processes logging to a
single file will are using only this class, and that the exact same
parameters are provided to each instance of this class. If, for
example, two different processes are using this class, but with
different values for 'maxBytes' or 'backupCount', then odd behavior is
expected. The same is true if this class is used by one application, but
the RotatingFileHandler is used by another.
NOTE: You should always provide 'filename' as an absolute path, since
this class will need to re-open the file during rotation. If your
application call os.chdir() then subsequent log files could be created
in the wrong directory.
"""
# The question of absolute paths: I'm not sure what the 'right thing' is
# to do here. RotatingFileHander simply ignores this possibility. I was
# going call os.path.abspath(), but that potentially limits uses. For
# example, on Linux (any posix system?) you can rename a directory of a
# running app, and the app wouldn't notice as long as it only opens new
# files using relative paths. But since that's not a "normal" thing to
# do, and having an app call os.chdir() is a much more likely scenario
# that should be supported. For the moment, we are just going to warn
# the user if they provide a relative path and do some other voodoo
# logic that you'll just have to review for yourself.
# if the given filename contains no path, we make an absolute path
if not os.path.isabs(filename):
if FORCE_ABSOLUTE_PATH or not os.path.split(filename)[0]:
filename = os.path.abspath(filename)
elif not supress_abs_warn:
from warnings import warn
warn(
"The given 'filename' should be an absolute path. If your "
"application calls os.chdir(), your logs may get messed up. "
"Use 'supress_abs_warn=True' to hide this message."
)
try:
BaseRotatingHandler.__init__(self, filename, mode, encoding)
except TypeError: # Due to a different logging release without encoding support (Python 2.4.1 and earlier?)
BaseRotatingHandler.__init__(self, filename, mode)
self.encoding = encoding
self._rotateFailed = False
self.maxBytes = maxBytes
self.backupCount = backupCount
# Prevent multiple extensions on the lock file (Only handles the normal "*.log" case.)
self.lock_file = "%s.lock" % filename
self.stream_lock = SoftFileLock(self.lock_file)
# For debug mode, swap out the "_degrade()" method with a more a verbose one.
if debug:
self._degrade = self._degrade_debug
def __init__(self, log_directory, logfile_prefix):
BaseRotatingHandler.__init__(self, "", 'a', encoding=None, delay=True)
self._log_directory = log_directory
self._logfile_prefix = logfile_prefix
self.doRollover()
def __init__(self, filename, when='h', interval=1, backupCount=0, encoding=None, delay=False, utc=False, debug=False):
"""
* interval, backupCount is not working!!! *
Just Copied from logging.handlers.TimedRotatingFileHandler
# a rollover occurs. Current 'when' events supported:
# S - Seconds
# M - Minutes
# H - Hours
# D - Days
# midnight - roll over at midnight
# W{0-6} - roll over on a certain day; 0 - Monday
#
# Case of the 'when' specifier is not important; lower or upper case
# will work.
"""
BaseRotatingHandler.__init__(self, filename, 'a', encoding, delay)
self.when = when.upper()
self.backupCount = backupCount
self.utc = utc
self.debug = debug
self.mylogfile = "%s.%08d" % ('/tmp/mptfhanldler', randint(0,99999999))
self.interval = 1 # datetime timedelta only have, days, seconds, microseconds
if self.when == 'S':
#self.interval = 1 # one second
self.suffix = "%Y-%m-%d_%H-%M-%S"
self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}$"
elif self.when == 'M':
self.interval = 60 # one minute
self.suffix = "%Y-%m-%d_%H-%M"
self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}$"
elif self.when == 'H':
self.interval = 60 * 60 # one hour
self.suffix = "%Y-%m-%d_%H"
self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}$"
elif self.when == 'D' or self.when == 'MIDNIGHT':
#self.interval = 60 * 60 * 24 # one day
self.suffix = "%Y-%m-%d"
self.extMatch = r"^\d{4}-\d{2}-\d{2}$"
self.when = 'D' # MIDNIGHT is day, use day only
elif self.when.startswith('W'):
#self.interval = 60 * 60 * 24 * 7 # one week
if len(self.when) != 2:
raise ValueError("You must specify a day for weekly rollover from 0 to 6 (0 is Monday): %s" % self.when)
if self.when[1] < '0' or self.when[1] > '6':
raise ValueError("Invalid day specified for weekly rollover: %s" % self.when)
self.dayOfWeek = int(self.when[1])
self.suffix = "%Y-%m-%d"
self.extMatch = r"^\d{4}-\d{2}-\d{2}$"
else:
raise ValueError("Invalid rollover interval specified: %s" % self.when)
self.extMatch = re.compile(self.extMatch)
#self.interval = self.interval * interval # multiply by units requested
self.interval = self.interval * 1 # interval arg is not working
# lock file, contain next rollover timestamp
self.stream_lock = None
self.lock_file = self._getLockFile()
# read from conf first for inherit the first process
# if it is the first process, please remove the lock file by hand first
self.nextRolloverTime = self.getNextRolloverTime()
if not self.nextRolloverTime:
self.nextRolloverTime = self.computerNextRolloverTime()
self.saveNextRolloverTime()
def __init__(self, filename, mode='a', encoding=None, delay=0):
self._shouldRoller = False
BaseRotatingHandler.__init__(self, filename, mode, encoding, delay)
def __init__ (self, file_pattern, encoding=None):
self.file_pattern = file_pattern
BaseRotatingHandler.__init__(self, self.get_baseFilename(),
"a", encoding)
def __init__(self, filename, mode='a', maxBytes=0, backupCount=0,
encoding=None, debug=True, supress_abs_warn=False):
"""
Open the specified file and use it as the stream for logging.
By default, the file grows indefinitely. You can specify particular
values of maxBytes and backupCount to allow the file to rollover at
a predetermined size.
Rollover occurs whenever the current log file is nearly maxBytes in
length. If backupCount is >= 1, the system will successively create
new files with the same pathname as the base file, but with extensions
".1", ".2" etc. appended to it. For example, with a backupCount of 5
and a base file name of "app.log", you would get "app.log",
"app.log.1", "app.log.2", ... through to "app.log.5". The file being
written to is always "app.log" - when it gets filled up, it is closed
and renamed to "app.log.1", and if files "app.log.1", "app.log.2" etc.
exist, then they are renamed to "app.log.2", "app.log.3" etc.
respectively.
If maxBytes is zero, rollover never occurs.
On Windows, it is not possible to rename a file that is currently opened
by another process. This means that it is not possible to rotate the
log files if multiple processes is using the same log file. In this
case, the current log file will continue to grow until the rotation can
be completed successfully. In order for rotation to be possible, all of
the other processes need to close the file first. A mechanism, called
"degraded" mode, has been created for this scenario. In degraded mode,
the log file is closed after each log message is written. So once all
processes have entered degraded mode, the next rotate log attempt should
be successful and then normal logging can be resumed.
This log handler assumes that all concurrent processes logging to a
single file will are using only this class, and that the exact same
parameters are provided to each instance of this class. If, for
example, two different processes are using this class, but with
different values for 'maxBytes' or 'backupCount', then odd behavior is
expected. The same is true if this class is used by one application, but
the RotatingFileHandler is used by another.
NOTE: You should always provide 'filename' as an absolute path, since
this class will need to re-open the file during rotation. If your
application call os.chdir() then subsequent log files could be created
in the wrong directory.
"""
# The question of absolute paths: I'm not sure what the 'right thing' is
# to do here. RotatingFileHander simply ignores this possibility. I was
# going call os.path.abspath(), but that potentially limits uses. For
# example, on Linux (any posix system?) you can rename a directory of a
# running app, and the app wouldn't notice as long as it only opens new
# files using relative paths. But since that's not a "normal" thing to
# do, and having an app call os.chdir() is a much more likely scenario
# that should be supported. For the moment, we are just going to warn
# the user if they provide a relative path and do some other voodoo
# logic that you'll just have to review for yourself.
# if the given filename contains no path, we make an absolute path
if not os.path.isabs(filename):
if FORCE_ABSOLUTE_PATH or \
not os.path.split(filename)[0]:
filename = os.path.abspath(filename)
elif not supress_abs_warn:
from warnings import warn
warn("The given 'filename' should be an absolute path. If your "
"application calls os.chdir(), your logs may get messed up. "
"Use 'supress_abs_warn=True' to hide this message.")
try:
BaseRotatingHandler.__init__(self, filename, mode, encoding)
except TypeError: # Due to a different logging release without encoding support (Python 2.4.1 and earlier?)
BaseRotatingHandler.__init__(self, filename, mode)
self.encoding = encoding
self._rotateFailed = False
self.maxBytes = maxBytes
self.backupCount = backupCount
# Prevent multiple extensions on the lock file (Only handles the normal "*.log" case.)
if filename.endswith(".log"):
lock_file = filename[:-4]
else:
lock_file = filename
self.stream_lock = open(lock_file + ".lock", "w")
# For debug mode, swap out the "_degrade()" method with a more a verbose one.
if debug:
self._degrade = self._degrade_debug
def __init__(self, filename, mode='a', when='h', backupCount=0, utc=False,
encoding=None, debug=True, delay=0, **kwargs):
"""
Open the specified file and use it as the stream for logging.
By default, the file grows indefinitely. You can specify particular
values of maxBytes and backupCount to allow the file to rollover at
a predetermined size.
Rollover occurs whenever the current log file is nearly maxBytes in
length. If backupCount is >= 1, the system will successively create
new files with the same pathname as the base file, but with extensions
".1", ".2" etc. appended to it. For example, with a backupCount of 5
and a base file name of "app.log", you would get "app.log",
"app.log.1", "app.log.2", ... through to "app.log.5". The file being
written to is always "app.log" - when it gets filled up, it is closed
and renamed to "app.log.1", and if files "app.log.1", "app.log.2" etc.
exist, then they are renamed to "app.log.2", "app.log.3" etc.
respectively.
If maxBytes is zero, rollover never occurs.
On Windows, it is not possible to rename a file that is currently opened
by another process. This means that it is not possible to rotate the
log files if multiple processes is using the same log file. In this
case, the current log file will continue to grow until the rotation can
be completed successfully. In order for rotation to be possible, all of
the other processes need to close the file first. A mechanism, called
"degraded" mode, has been created for this scenario. In degraded mode,
the log file is closed after each log message is written. So once all
processes have entered degraded mode, the net rotation attempt should
be successful and then normal logging can be resumed. Using the 'delay'
parameter may help reduce contention in some usage patterns.
This log handler assumes that all concurrent processes logging to a
single file will are using only this class, and that the exact same
parameters are provided to each instance of this class. If, for
example, two different processes are using this class, but with
different values for 'maxBytes' or 'backupCount', then odd behavior is
expected. The same is true if this class is used by one application, but
the RotatingFileHandler is used by another.
"""
# Absolute file name handling done by FileHandler since Python 2.5
BaseRotatingHandler.__init__(self, filename, mode, encoding, delay)
self.delay = delay
self._rotateFailed = False
self.when = when.upper()
if self.when == 'S':
self.interval = 1 # one second
self.suffix = "%Y-%m-%d_%H-%M-%S"
self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}$"
elif self.when == 'M':
self.interval = 60 # one minute
self.suffix = "%Y-%m-%d_%H-%M"
self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}$"
elif self.when == 'H':
self.interval = 60 * 60 # one hour
self.suffix = "%Y-%m-%d_%H"
self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}$"
elif self.when == 'D' or self.when == 'MIDNIGHT':
self.interval = 60 * 60 * 24 # one day
self.suffix = "%Y-%m-%d"
self.extMatch = r"^\d{4}-\d{2}-\d{2}$"
elif self.when.startswith('W'):
self.interval = 60 * 60 * 24 * 7 # one week
if len(self.when) != 2:
raise ValueError("You must specify a day for weekly rollover from 0 to 6 (0 is Monday): %s" % self.when)
if self.when[1] < '0' or self.when[1] > '6':
raise ValueError("Invalid day specified for weekly rollover: %s" % self.when)
self.dayOfWeek = int(self.when[1])
self.suffix = "%Y-%m-%d"
self.extMatch = r"^\d{4}-\d{2}-\d{2}$"
else:
raise ValueError("Invalid rollover interval specified: %s" % self.when)
self.extMatch = re.compile(self.extMatch)
self.backupCount = backupCount
self.utc = utc
if utc:
self._get_time = lambda: time.strftime(self.suffix, time.gmtime())
else:
self._get_time = lambda: time.strftime(self.suffix, time.localtime())
self.time = self._get_time()
self._open_lockfile()
# For debug mode, swap out the "_degrade()" method with a more a verbose one.
if debug:
self._degrade = self._degrade_debug
self.callback = kwargs.get('callback', None)
