अजगर, चाहते लॉग रोटेशन और संपीड़न

Question

साथ प्रवेश करने किसी को भी अजगर में एक तरह से बता सकते हैं के साथ प्रवेश करने करने के लिए:

• लॉग रोटेशन हर दिन लॉग के
• संपीड़न जब वे घुमाया रहे
• वैकल्पिक -
• वैकल्पिक मुक्त अंतरिक्ष के एक्स एमबी संरक्षित करने के लिए सबसे पुराना लॉग फ़ाइल को नष्ट - किसी भी प्रतिक्रिया के लिए सर्वर

धन्यवाद करने के लिए SFTP लॉग फाइल, फ्रेड

Answer 1

• लॉग रोटेशन हर दिन: लॉग के TimedRotatingFileHandler
• संपीड़न का उपयोग करें: encoding='bz2' पैरामीटर सेट। (ध्यान दें कि यह "चाल" केवल Python2 के लिए काम करेगा। 'Bz2' को अब Python3 में एन्कोडिंग नहीं माना जाता है।)
• वैकल्पिक - एक्सबी मुक्त स्थान को संरक्षित करने के लिए सबसे पुरानी लॉग फ़ाइल हटाएं। आप RotatingFileHandler का उपयोग करके इसे (अप्रत्यक्ष रूप से) व्यवस्थित कर सकते हैं। maxBytes पैरामीटर सेट करके, लॉग फ़ाइल रोलओवर होगा जब यह किसी निश्चित आकार तक पहुंच जाए। backupCount पैरामीटर सेट करके, आप नियंत्रित कर सकते हैं कि कितने रोलओवर रखे गए हैं। एक साथ दो पैरामीटर आपको लॉग फ़ाइलों द्वारा खपत अधिकतम स्थान को नियंत्रित करने की अनुमति देते हैं। आप इस व्यवहार को शामिल करने के लिए शायद TimeRotatingFileHandler को उपclass कर सकते हैं।

---

बस मस्ती के लिए, यहाँ है कि कैसे आप TimeRotatingFileHandler उपवर्ग सकता है। जब आप नीचे लिपि चलाते हैं, तो यह /tmp/log_rotate* पर लॉग फ़ाइलों को लिख देगा।

time.sleep (जैसे 0.1) के लिए एक छोटे से मूल्य के साथ, लॉग फ़ाइलें जल्दी भर जाती हैं, अधिकतमबाइट सीमा तक पहुंच जाती हैं, और फिर लुढ़क जाती हैं।

बड़े time.sleep (जैसे 1.0) के साथ, लॉग फ़ाइलें धीरे-धीरे भर जाती हैं, अधिकतम बाइट्स सीमा तक नहीं पहुंचती है, लेकिन जब भी समय अंतराल (10 सेकंड) तक पहुंच जाता है तो वे रोल हो जाते हैं।

नीचे दिए गए सभी कोड logging/handlers.py से आते हैं। मैंने बस रोटेटिंगफाइलहैंडलर के साथ टाइमरोटिंगफाइलहैंडलर को सबसे सीधे आगे बढ़ने के तरीके में मेस किया।

import time 
import re 
import os 
import stat 
import logging 
import logging.handlers as handlers 


class SizedTimedRotatingFileHandler(handlers.TimedRotatingFileHandler): 
    """ 
    Handler for logging to a set of files, which switches from one file 
    to the next when the current file reaches a certain size, or at certain 
    timed intervals 
    """ 

    def __init__(self, filename, maxBytes=0, backupCount=0, encoding=None, 
       delay=0, when='h', interval=1, utc=False): 
     handlers.TimedRotatingFileHandler.__init__(
      self, filename, when, interval, backupCount, encoding, delay, utc) 
     self.maxBytes = maxBytes 

    def shouldRollover(self, record): 
     """ 
     Determine if rollover should occur. 

     Basically, see if the supplied record would cause the file to exceed 
     the size limit we have. 
     """ 
     if self.stream is None:     # delay was set... 
      self.stream = self._open() 
     if self.maxBytes > 0:     # are we rolling over? 
      msg = "%s\n" % self.format(record) 
      # due to non-posix-compliant Windows feature 
      self.stream.seek(0, 2) 
      if self.stream.tell() + len(msg) >= self.maxBytes: 
       return 1 
     t = int(time.time()) 
     if t >= self.rolloverAt: 
      return 1 
     return 0 


def demo_SizedTimedRotatingFileHandler(): 
    log_filename = '/tmp/log_rotate' 
    logger = logging.getLogger('MyLogger') 
    logger.setLevel(logging.DEBUG) 
    handler = SizedTimedRotatingFileHandler(
     log_filename, maxBytes=100, backupCount=5, 
     when='s', interval=10, 
     # encoding='bz2', # uncomment for bz2 compression 
    ) 
    logger.addHandler(handler) 
    for i in range(10000): 
     time.sleep(0.1) 
     logger.debug('i=%d' % i) 

demo_SizedTimedRotatingFileHandler() 

Answer 2

unutbu के जवाब के अलावा: यहाँ कैसे ज़िप फ़ाइलों का उपयोग कर संपीड़ित करने के लिए TimedRotatingFileHandler संशोधित करने के लिए है।

import logging 
import logging.handlers 
import zipfile 
import codecs 
import sys 
import os 
import time 
import glob 


class TimedCompressedRotatingFileHandler(logging.handlers.TimedRotatingFileHandler): 
    """ 
    Extended version of TimedRotatingFileHandler that compress logs on rollover. 
    """ 
    def doRollover(self): 
     """ 
     do a rollover; in this case, a date/time stamp is appended to the filename 
     when the rollover happens. However, you want the file to be named for the 
     start of the interval, not the current time. If there is a backup count, 
     then we have to get a list of matching filenames, sort them and remove 
     the one with the oldest suffix. 
     """ 

     self.stream.close() 
     # get the time that this sequence started at and make it a TimeTuple 
     t = self.rolloverAt - self.interval 
     timeTuple = time.localtime(t) 
     dfn = self.baseFilename + "." + time.strftime(self.suffix, timeTuple) 
     if os.path.exists(dfn): 
      os.remove(dfn) 
     os.rename(self.baseFilename, dfn) 
     if self.backupCount > 0: 
      # find the oldest log file and delete it 
      s = glob.glob(self.baseFilename + ".20*") 
      if len(s) > self.backupCount: 
       s.sort() 
       os.remove(s[0]) 
     #print "%s -> %s" % (self.baseFilename, dfn) 
     if self.encoding: 
      self.stream = codecs.open(self.baseFilename, 'w', self.encoding) 
     else: 
      self.stream = open(self.baseFilename, 'w') 
     self.rolloverAt = self.rolloverAt + self.interval 
     if os.path.exists(dfn + ".zip"): 
      os.remove(dfn + ".zip") 
     file = zipfile.ZipFile(dfn + ".zip", "w") 
     file.write(dfn, os.path.basename(dfn), zipfile.ZIP_DEFLATED) 
     file.close() 
     os.remove(dfn) 

Answer 3

घुमाने के दौरान लॉगफ़ाइल (अजगर 3.3 में नया) संपीड़ित करने के लिए अन्य तरीके से BaseRotatingHandler उपयोग कर रहा है (और सभी विरासत में मिला है) वर्ग विशेषता रोटेटर उदाहरण के लिए:

import gzip 
import os 
import logging 
import logging.handlers 

class GZipRotator: 
    def __call__(self, source, dest): 
     os.rename(source, dest) 
     f_in = open(dest, 'rb') 
     f_out = gzip.open("%s.gz" % dest, 'wb') 
     f_out.writelines(f_in) 
     f_out.close() 
     f_in.close() 
     os.remove(dest) 

logformatter = logging.Formatter('%(asctime)s;%(levelname)s;%(message)s') 
log = logging.handlers.TimedRotatingFileHandler('debug.log', 'midnight', 1, backupCount=5) 
log.setLevel(logging.DEBUG) 
log.setFormatter(logformatter) 
log.rotator = GZipRotator() 

logger = logging.getLogger('main') 
logger.addHandler(log)  
logger.setLevel(logging.DEBUG) 

.... 

अधिक आप here देख सकते हैं।

Answer 4

फाइल कॉपी करने के लिए, की नकल की फ़ाइल gzip (युग समय का उपयोग कर), और फिर एक तरीका है कि प्रवेश मॉड्यूल परेशान नहीं करेगा में मौजूदा फ़ाइल बाहर समाशोधन:

import gzip 
import logging 
import os 
from shutil import copy2 
from time import time 

def logRoll(logfile_name): 
    log_backup_name = logfile_name + '.' + str(int(time())) 
    try: 
     copy2(logfile_name, log_backup_name) 
    except IOError, err: 
     logging.debug(' No logfile to roll') 
     return 
    f_in = open(log_backup_name, 'rb') 
    f_out = gzip.open(log_backup_name + '.gz', 'wb') 
    f_out.writelines(f_in) 
    f_out.close() 
    f_in.close() 
    os.remove(log_backup_name) 
    f=open(logfile_name, 'w') 
    f.close() 

Answer 5

मुझे लगता है कि यह बहुत देर हो चुकी पार्टी में शामिल होने के लिए, लेकिन यहां मैंने जो किया है। मैंने logging.handlers.RotatingFileHandler कक्षा विरासत में एक नई कक्षा बनाई और इसे स्थानांतरित करने से पहले फ़ाइल को gzip करने के लिए कुछ पंक्तियां जोड़ दीं।

https://github.com/rkreddy46/python_code_reference/blob/master/compressed_log_rotator.py

#!/usr/bin/env python 

# Import all the needed modules 
import logging.handlers 
import sys 
import time 
import gzip 
import os 
import shutil 
import random 
import string 

__version__ = 1.0 
__descr__ = "This logic is written keeping in mind UNIX/LINUX/OSX platforms only" 


# Create a new class that inherits from RotatingFileHandler. This is where we add the new feature to compress the logs 
class CompressedRotatingFileHandler(logging.handlers.RotatingFileHandler): 
    def doRollover(self): 
     """ 
     Do a rollover, as described in __init__(). 
     """ 
     if self.stream: 
      self.stream.close() 
     if self.backupCount > 0: 
      for i in range(self.backupCount - 1, 0, -1): 
       sfn = "%s.%d.gz" % (self.baseFilename, i) 
       dfn = "%s.%d.gz" % (self.baseFilename, i + 1) 
       if os.path.exists(sfn): 
        # print "%s -> %s" % (sfn, dfn) 
        if os.path.exists(dfn): 
         os.remove(dfn) 
        os.rename(sfn, dfn) 
      dfn = self.baseFilename + ".1.gz" 
      if os.path.exists(dfn): 
       os.remove(dfn) 
      # These two lines below are the only new lines. I commented out the os.rename(self.baseFilename, dfn) and 
      # replaced it with these two lines. 
      with open(self.baseFilename, 'rb') as f_in, gzip.open(dfn, 'wb') as f_out: 
       shutil.copyfileobj(f_in, f_out) 
      # os.rename(self.baseFilename, dfn) 
      # print "%s -> %s" % (self.baseFilename, dfn) 
     self.mode = 'w' 
     self.stream = self._open() 

# Specify which file will be used for our logs 
log_filename = "/Users/myname/Downloads/test_logs/sample_log.txt" 

# Create a logger instance and set the facility level 
my_logger = logging.getLogger() 
my_logger.setLevel(logging.DEBUG) 

# Create a handler using our new class that rotates and compresses 
file_handler = CompressedRotatingFileHandler(filename=log_filename, maxBytes=1000000, backupCount=10) 

# Create a stream handler that shows the same log on the terminal (just for debug purposes) 
view_handler = logging.StreamHandler(stream=sys.stdout) 

# Add all the handlers to the logging instance 
my_logger.addHandler(file_handler) 
my_logger.addHandler(view_handler) 

# This is optional to beef up the logs 
random_huge_data = "".join(random.choice(string.ascii_letters) for _ in xrange(10000)) 

# All this code is user-specific, write your own code if you want to play around 
count = 0 
while True: 
    my_logger.debug("This is the message number %s" % str(count)) 
    my_logger.debug(random_huge_data) 
    count += 1 
    if count % 100 == 0: 
     count = 0 
     time.sleep(2) 

Answer 6

मुझे लगता है कि सबसे अच्छा विकल्प TimedRotatingFileHandler की और घुमाया संस्करण के लिए लॉग फ़ाइल का नाम बदलने बस इसे सेक के बाद वर्तमान कार्यान्वयन का उपयोग करने के लिए किया जाएगा:

import zipfile 
import os 
from logging.handlers import TimedRotatingFileHandler 


class TimedCompressedRotatingFileHandler(TimedRotatingFileHandler): 
    """ 
    Extended version of TimedRotatingFileHandler that compress logs on rollover. 
    """ 
    def find_last_rotated_file(self): 
     dir_name, base_name = os.path.split(self.baseFilename) 
     file_names = os.listdir(dir_name) 
     result = [] 
     prefix = '{}.20'.format(base_name) # we want to find a rotated file with eg filename.2017-12-12... name 
     for file_name in file_names: 
      if file_name.startswith(prefix) and not file_name.endswith('.zip'): 
       result.append(file_name) 
     result.sort() 
     return result[0] 

    def doRollover(self): 
     super(TimedCompressedRotatingFileHandler, self).doRollover() 

     dfn = self.find_last_rotated_file() 
     dfn_zipped = '{}.zip'.format(dfn) 
     if os.path.exists(dfn_zipped): 
      os.remove(dfn_zipped) 
     with zipfile.ZipFile(dfn_zipped, 'w') as f: 
      f.write(dfn, dfn_zipped, zipfile.ZIP_DEFLATED) 
     os.remove(dfn)