Cosa voglio ottenere ?
Voglio scaricare tutti i registri in una singola riga che è stata raccolta durante una richiesta.
Perché lo sto facendo?
-
Approccio generale, ad esempio logger.info (), esegue il dump del file di accesso contemporaneamente quando si chiama la funzione. A causa di ciò, i log vengono confusi e non possono leggerli in sequenza poiché più thread utilizzano lo stesso file.
By my approach, all logs will get collected in memory during request, will dump once just before we are returning response. Now I can read log easily as all logs belong to the request are in single line.
Non è un buon approccio, quali possono essere i problemi?
-
Meno IO, sto memorizzando tutti i registri in memoria e scaricando immediatamente.
What I believe IO contribute some part of response time, also IO is more costly then Memory. My approach somehow contributing to improve performance.
Mi sbaglio?
Come sto cercando di fare?
Creazione di una classe di registrazione personalizzata che sarà singleton (per richiesta) sulla base del nome file del registro. Ha i suoi metodi proprio come il logger, ad esempio informazioni, errori, ecc. Ma memorizzerà solo i registri in memoria (raccogliendo i registri nell'elenco). Abbiamo bisogno di chiamare il metodo dump per effettuare il log in realtà (chiamando i metodi .info, .error quando l'intera richiesta è completa).
È un approccio sbagliato?
Frammenti di codice
Presupposti: Per raggiungere, apriremo multiprocessi solo in uwsgi e non nel multi-thread.
file: customlogging.py
import logging
class MyLogging(object):
"""This will return singleton object as per filename."""
_instance = {}
def __new__(cls, file_name):
if not cls._instance.get(file_name):
cls._instance = super(MyLogging, cls).__new__(cls, file_name)
return cls._instance
def __init__(self, file_name):
self.logger = logging.getLogger(file_name')
self.info_log = []
self.error_log = []
def log_append(self, logtype, msg):
"""
Appending into log .
"""
d = getattr(self, '%s_log' % logtype)
d.append(msg)
def info(self, msg):
self.log_append('info', msg)
def error(self, msg):
self.log_append('error', msg)
def dump(self):
self.logger.info(",".join(self.info_log))
self.logger.info(",".join(self.error_log))
file: app / abc.py
mylogger = MyLogging('app.abc')
def abc(request):
mylogging.info(request.data)
# doing something.
mylogging.error("something")
return httpresponse
file: utils.py
mylogger = MyLogging('app.abc')
def abc_util(arg):
mylogging.info(arg)
file: middleware / dump_log.py
mylogger = MyLogging('app.abc')
class LogDumpMiddleware(object):
def process_response(self, request, response):
mylogger.dump()
# Assumption: Multi Processes not multi threaded.
mylogger._instance = None
return response