def __init__(self):
print('LogHandler')
try:
#log formatter
jsonFormat = json_log_formatter.JSONFormatter()
#transactionLog
transactionLogHandler = logging.FileHandler(filename="logs/transaction.json")
transactionLogHandler.setFormatter(jsonFormat)
self.transactionLogger = logging.getLogger('transaction')
self.transactionLogger.addHandler(transactionLogHandler)
self.transactionLogger.setLevel(logging.INFO)
#error logger
errorLogHandler = logging.FileHandler(filename="logs/error.json")
errorLogHandler.setFormatter(jsonFormat)
self.errorLogger = logging.getLogger('error')
self.errorLogger.addHandler(errorLogHandler)
self.errorLogger.setLevel(logging.ERROR)
#data logger
dataLogHandler = logging.FileHandler(filename="logs/data.json")
dataLogHandler.setFormatter(jsonFormat)
self.dataLogger = logging.getLogger('data')
self.dataLogger.addHandler(dataLogHandler)
self.dataLogger.setLevel(logging.INFO)
except Exception as ex:
print(str(ex))
def setup_log():
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(json_log_formatter.JSONFormatter())
logger = logging.getLogger(__name__)
logger.addHandler(handler)
logger.setLevel(logging.INFO)
return logger
def configure_logs():
formatter = json_log_formatter.JSONFormatter()
json_handler = logging.StreamHandler()
json_handler.setFormatter(formatter)
LOGGER = logging.getLogger('kiki')
LOGGER.addHandler(json_handler)
LOGGER.setLevel(logging.INFO)
def __init__(self,cfg,db):
# queue log
if cfg.queue_logtype=='json':
formatter = json_log_formatter.JSONFormatter()
json_handler = logging.FileHandler(filename=cfg.queue_logfile)
json_handler.setFormatter(formatter)
qlogger = logging.getLogger('my_json')
qlogger.addHandler(json_handler)
qlogger.setLevel(logging.INFO)
elif cfg.queue_logtype=='csv':
qlogger = open(cfg.queue_logfile,'a',0)
else:
print "Logging configuration error. Exit."
sys.exit(1)
# app log
alogger = open(cfg.app_logfile,'a',0)
self.logtype=cfg.queue_logtype
self.alog=alogger
self.qlog=qlogger
self.db=db
def __init__(self):
#log formatter
jsonFormat = json_log_formatter.JSONFormatter()
#httpLogger
httpLogHandler = logging.FileHandler(filename="logs/http.json")
httpLogHandler.setFormatter(jsonFormat)
self.httpLogger = logging.getLogger('http')
self.httpLogger.addHandler(httpLogHandler)
self.httpLogger.setLevel(logging.INFO)
#server Switch logger
ssLogHandler = logging.FileHandler(filename="logs/ss.json")
ssLogHandler.setFormatter(jsonFormat)
self.ssLogger = logging.getLogger('ss')
self.ssLogger.addHandler(ssLogHandler)
self.ssLogger.setLevel(logging.INFO)
#error logger
errorLogHandler = logging.FileHandler(filename="logs/error.json")
errorLogHandler.setFormatter(jsonFormat)
self.errorLogger = logging.getLogger('error')
self.errorLogger.addHandler(errorLogHandler)
self.errorLogger.setLevel(logging.ERROR)
#data logger
dataLogHandler = logging.FileHandler(filename="logs/data.json")
dataLogHandler.setFormatter(jsonFormat)
self.dataLogger = logging.getLogger('data')
self.dataLogger.addHandler(dataLogHandler)
self.dataLogger.setLevel(logging.INFO)
class JsonLog:
import logging
import json_log_formatter
formatter = json_log_formatter.JSONFormatter()
json_handler = logging.StreamHandler(
) # .FileHandler(filename="salesdesk_logs.json") to export logs in file
json_handler.setFormatter(formatter)
logger = logging.getLogger('log_json')
logger.addHandler(json_handler)
logger.setLevel(logging.INFO)
def __init__(self, filename):
self.uuid = str(uuid4())
formatter = json_log_formatter.JSONFormatter()
json_handler = logging.FileHandler(filename=filename + ".logs")
json_handler.setFormatter(formatter)
self.logger = logging.getLogger('my_json')
self.logger.addHandler(json_handler)
self.logger.setLevel(logging.DEBUG)
def __init__(self):
self.logger = logging.getLogger('logger')
self.logger.setLevel(logging.INFO)
# Stdout
formatter = json_log_formatter.JSONFormatter()
stream_handler = logging.StreamHandler(sys.stdout)
if not settings.DEBUG:
stream_handler.setFormatter(formatter)
self.logger.addHandler(stream_handler)
self.enabled = True
def init_logging(logging_level, logging_format):
logger = logging.getLogger()
logger.setLevel(logging_level)
if logging_format == 'LINE':
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
elif logging_format == 'JSON':
formatter = json_log_formatter.JSONFormatter()
else:
raise ValueError('unknown log format, something has gone terribly wrong')
lh = logging.StreamHandler()
lh.setFormatter(formatter)
logger.addHandler(lh)
def init_logger(file_location='log.json'):
formatter = json_log_formatter.JSONFormatter()
json_handler = logging.FileHandler(filename=file_location)
json_handler.setFormatter(formatter)
stdout_handler = logging.StreamHandler(sys.stdout)
stdout_handler.setFormatter(
logging.Formatter('%(asctime)s - %(name)s - %(message)s'))
log = logging.getLogger('IPS')
log.addHandler(json_handler)
log.addHandler(stdout_handler)
log.setLevel(logging.DEBUG)
def init_logging(app):
"""
Configure flask logger to support structured logging
http://flask.pocoo.org/docs/dev/logging/
https://github.com/marselester/json-log-formatter
"""
# Removing default logger
app.logger.removeHandler(default_handler)
formatter = json_log_formatter.JSONFormatter()
hndlr = logging.StreamHandler()
hndlr.setFormatter(formatter)
app.logger.addHandler(hndlr)
log_level = app.config['LOG_LEVEL']
app.logger.setLevel(log_level)
def configure_logging(env_var: str):
log_level = os.environ.get(env_var, 'INFO')
if 'DD_LOGS_INJECTION' in os.environ:
import json_log_formatter
formatter = json_log_formatter.JSONFormatter()
handler = logging.StreamHandler()
handler.setFormatter(formatter)
logger = logging.getLogger()
logger.handlers = []
logger.setLevel(log_level)
logger.addHandler(handler)
else:
import sys
logging.basicConfig(stream=sys.stdout, level=log_level)
def runLogging(**logging_info):
for item in logging_info:
if item == 'log_dir':
log_dir = logging_info[item]
print "logging in directory", logging_info[item]
if item == 'log_level':
print "with current logging level", logging_info[item]
logFileName = os.path.join(log_dir,'my-log.json')
testFormatStr = '%(message)%(levelname)%(name)%(asctime)'
testFormatter = json_log_formatter.JSONFormatter(testFormatStr)
testJSONhandler = logging.FileHandler(filename=logFileName)
testJSONhandler.setFormatter(testFormatter)
testLogger = logging.getLogger('my_json')
testLogger.addHandler(testJSONhandler)
testLogger.setLevel(logging.INFO)
testLogger.info('test Info Message')
testLogger.error('test Error Message')
return
def get_root_logger(logger_name, filename=None):
''' get the logger object '''
debug = os.environ.get('ENV', 'development') == 'development'
formatter = json_log_formatter.JSONFormatter()
# formatter = json.dumps({
# "time": "%(asctime)s",
# "levelname": "%(levelname)s",
# "name": "%(name)s",
# "message": "%(message)s"
# })
log_handler = logging.StreamHandler()
log_handler.setFormatter(formatter)
logger = logging.getLogger(logger_name)
logger.addHandler(log_handler)
logger.setLevel(logging.INFO)
return logger
dest="room",
help="MUC room to connect to",
default=None)
opts, args = optp.parse_args()
# Setup logging.
logging.basicConfig(level=opts.loglevel,
format='%(asctime)s %(levelname)-8s %(message)s',
filename=opts.syslogfile,
filemode='w')
# logging.basicConfig(level=opts.loglevel,
# format='%(asctime)s %(levelname)-8s %(message)s')
#
formatter = json_log_formatter.JSONFormatter(
'%(message)%(levelname)%(name)%(asctime)')
formatter.converter = time.gmtime()
json_handler = logging.FileHandler(
opts.trafficlogfile) # later put it in one file! concatenating
json_handler.setFormatter(formatter)
logger = logging.getLogger('json')
logger.addHandler(json_handler)
logger.setLevel(logging.DEBUG)
# logger.info("test",extra = {"aa,bb,cc":opts.nodeid})
if opts.jid is None:
opts.jid = raw_input("Username: "******"Password: "******"setting the individual to " + str(opts.individual))
# Configuração de request uuid para rastreio de requisições
RequestID(app)
# Configuração de exporter de métricas para prometheus
metrics = PrometheusMetrics(app)
metrics.info("info", "twitterapi", version="1.0.0")
# Configuração da aplicação a partir de variáveis de ambiente
app.config['MONGO_DB_HOST'] = os.environ.get("MONGO_DB_HOST")
app.config['MONGO_DB_PORT'] = os.environ.get("MONGO_DB_PORT")
# Configuração de LOG da
applog = logging.getLogger(__name__)
applog.setLevel(logging.DEBUG)
formatter_json = json_log_formatter.JSONFormatter()
file_handler = RotatingFileHandler('/app/logs/twitterapi.log',
maxBytes=104857600,
backupCount=10)
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(formatter_json)
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.DEBUG)
stream_handler.setFormatter(formatter_json)
applog.addHandler(file_handler)
applog.addHandler(stream_handler)
applog.debug("config", extra=app.config)
import hashlib
import json
import logging
import operator
from cachetools import TTLCache, cachedmethod
import json_log_formatter
import requests
logger = logging.getLogger(__name__)
struct_logger = logging.getLogger('autoscaler.notification.struct')
formatter = json_log_formatter.JSONFormatter()
handler = logging.StreamHandler()
handler.setFormatter(formatter)
struct_logger.addHandler(handler)
struct_logger.setLevel(logging.DEBUG)
struct_logger.propagate = False
def _cache_key(notifier, owner, message, pods):
md5 = hashlib.md5()
md5.update(owner)
md5.update(message)
for pod in sorted(pods, key=lambda p: p.uid):
md5.update(pod.uid)
key = 'v0.md5.{}'.format(md5.hexdigest())
return key
def runJsonLogFormatter(self):
print('json_log_formatter.JSONFormatter')
logger = logging.getLogger(self.LOGGER_NAME)
logger.setLevel(logging.DEBUG)
logHandler = logging.StreamHandler()
logger.addHandler(logHandler)
formatter = json_log_formatter.JSONFormatter()
logHandler.setFormatter(formatter)
logger.setLevel(logging.DEBUG)
msg = {"text": "testing logging", "num": 1, 5: "9", "nested": {"more": "data"}}
logger.info(msg=msg)
extra = {"text": "testing logging", "num": 1, 5: "9", "nested": {"more": "data"}}
logger.info("hello", extra=extra)
SUPPORTED_KEYS = {
'args',
'asctime',
'created',
'exc_info',
'exc_text',
'filename',
'funcName',
'levelname',
'levelno',
'lineno',
'module',
'msecs',
'message',
'msg',
'name',
'pathname',
'process',
'processName',
'relativeCreated',
'stack_info',
'thread',
'threadName',
}
def log_format(x):
return ['%({0:s})'.format(i) for i in x]
custom_format = ' '.join(log_format(SUPPORTED_KEYS))
formatter = json_log_formatter.JSONFormatter(custom_format)
logHandler.setFormatter(formatter)
msg = "testing logging format"
logger.info(msg=msg)
msg = {"text": "testing logging", "num": 1, 5: "9", "nested": {"more": "data"}}
logger.info(msg=msg)
extra = {"text": "testing logging", "num": 1, 5: "9", "nested": {"more": "data"}}
logger.info("hello", extra=extra)
