def __init__(self, cfg):
super(Logger, self).__init__(cfg)
access_handler = MongoHandler(level=INFO,
collection='access-logs',
**DB('MONGOLAB_URI').URI)
error_handler = MongoHandler(level=INFO,
collection='error-logs',
**DB('MONGOLAB_URI').URI)
access_handler.setFormatter(MongoFormatter())
error_handler.setFormatter(MongoFormatter())
self.access_log.addHandler(access_handler)
self.access_log.setLevel(INFO)
self.error_log.addHandler(error_handler)
self.error_log.setLevel(INFO)
def test_override_capped_collection(self):
# Creating capped handler
self.handler_capped = MongoHandler(
host=self.host_name, database_name=self.database_name,
collection=self.collection_name, capped=True,
capped_max=self.capped_max)
self.log.removeHandler(self.handler)
self.log.addHandler(self.handler)
self.log.info('test info')
# Creating no capped handler
self.handler_no_capped = MongoHandler(host=self.host_name,
database_name=self.database_name,
collection=self.collection_name)
self.log.addHandler(self.handler_no_capped)
self.log.info('test info')
def test_1_connect_failed(self):
log4mongo.handlers._connection = None
kwargs = {'connectTimeoutMS': 2000, 'serverselectiontimeoutms': 2000}
if pymongo.version_tuple[0] < 3:
with self.assertRaises(PyMongoError):
MongoHandler(host='unknow_host',
database_name=self.database_name,
collection=self.collection_name,
**kwargs)
else:
with self.assertRaises(ServerSelectionTimeoutError):
MongoHandler(host='unknow_host',
database_name=self.database_name,
collection=self.collection_name,
**kwargs)
def setup_handlers():
handler_id = 'log4mongo_handler'
if handler_id not in __opts__:
yield False
config_fields = {
'host': 'host',
'port': 'port',
'database_name': 'database_name',
'collection': 'collection',
'username': '******',
'password': '******',
'write_concern': 'w'
}
config_opts = {}
for config_opt, arg_name in config_fields.iteritems():
config_opts[arg_name] = __opts__[handler_id].get(config_opt)
config_opts['level'] = LOG_LEVELS[__opts__[handler_id].get(
'log_level', __opts__.get('log_level', 'error'))]
handler = MongoHandler(formatter=FormatterWithHost(), **config_opts)
yield handler
def test_connect(self):
handler = MongoHandler(host='localhost',
database_name=self.database_name,
collection=self.collection_name)
self.assertTrue(isinstance(handler, MongoHandler))
self.handler.connection.drop_database(self.database_name)
handler.close()
def _get_mongo_handler(self):
handler = MongoHandler(
host=os.environ.get('PYPE_LOG_MONGO_HOST'),
port=int(os.environ.get('PYPE_LOG_MONGO_PORT')),
database_name=os.environ.get('PYPE_LOG_MONGO_DB'),
capped=True,
formatter=PypeMongoFormatter())
return handler
def test_connect_failed_silent(self):
handler = MongoHandler(host='unknow_host',
database_name=self.database_name,
collection=self.collection_name,
fail_silently=True)
self.assertTrue(isinstance(handler, MongoHandler))
self.handler.connection.drop_database(self.database_name)
handler.close()
def setUp(self):
self.handler = MongoHandler(host=self.host_name, database_name=self.database_name,
collection=self.collection_name, capped=True, capped_max=self.capped_max)
self.log = logging.getLogger('testLogger')
self.log.setLevel(logging.DEBUG)
self.log.addHandler(self.handler)
self.old_stderr = sys.stdout
sys.stderr = StringIO()
def test_emit_on_reconnect_existing_capped_collection(self):
self.log.removeHandler(self.handler)
handler = MongoHandler(host=self.host_name, database_name=self.database_name,
collection=self.collection_name, capped=True, capped_max=self.capped_max)
self.log.addHandler(handler)
self.log.warning('test message')
document = handler.collection.find_one({'message': 'test message', 'level': 'WARNING'})
self.assertEqual(document['message'], 'test message')
self.assertEqual(document['level'], 'WARNING')
def test_connect_failed_silent(self):
log4mongo.handlers._connection = None
kwargs = {'connectTimeoutMS': 2000, 'serverselectiontimeoutms': 2000}
handler = MongoHandler(host='unknow_host',
database_name=self.database_name,
collection=self.collection_name,
fail_silently=True,
**kwargs)
self.assertTrue(isinstance(handler, MongoHandler))
self.handler.connection.drop_database(self.database_name)
handler.close()
def __init__(self, cfg):
super(GunicornLogger, self).__init__(cfg)
if PRODUCTION:
access_handler = MongoHandler(level=INFO,
collection='access-log',
**MONGOLAB_CONF_DICT)
error_handler = MongoHandler(level=INFO,
collection='error-log',
**MONGOLAB_CONF_DICT)
access_handler.setFormatter(MongoFormatter())
error_handler.setFormatter(MongoFormatter())
self.error_log.addHandler(error_handler)
self.error_log.setLevel(INFO)
else:
access_handler = StreamHandler()
access_handler.setFormatter(
Formatter(
'%(asctime)s [%(process)d] [%(levelname)s/ACCESS] %(message)s',
'%Y.%m:%d %H:%M:%S'))
self.access_log.addHandler(access_handler)
self.access_log.setLevel(INFO)
def __init__(self, cfg):
super(Logger, self).__init__(cfg)
access_handler = MongoHandler(level=INFO,
host=MONGOLAB.hostname,
port=MONGOLAB.port,
database_name=MONGOLAB.path[1:],
collection='access-logs',
username=MONGOLAB.username,
password=MONGOLAB.password)
error_handler = MongoHandler(level=INFO,
host=MONGOLAB.hostname,
port=MONGOLAB.port,
database_name=MONGOLAB.path[1:],
collection='error-logs',
username=MONGOLAB.username,
password=MONGOLAB.password)
access_handler.setFormatter(MongoFormatter())
error_handler.setFormatter(MongoFormatter())
self.access_log.addHandler(access_handler)
self.access_log.setLevel(INFO)
self.error_log.addHandler(error_handler)
self.error_log.setLevel(INFO)
def __init__(self, mongo_host, database_name='mongo_logs',
log_level='warning', send_mail=False, debug=False, mail_list=[]):
self.logger = logging.getLogger('mongo_logger')
self.logger.setLevel(levels.get('debug'))
if send_mail:
mail_handler = SMTPHandler('smtp.qq.com', '*****@*****.**', mail_list, 'HuiMouKe Server Error',
('*****@*****.**', 'nffzqgrokerxcaia'), ())
mail_handler.setLevel(logging.ERROR)
logging.root.addHandler(mail_handler)
if not debug:
mon = MongoHandler(host=mongo_host, database_name=database_name)
mon.setLevel(levels.get(log_level, 'warning'))
logging.root.addHandler(MongoHandler)
# 给当前所有存在的handler重新设置规则
[i.setFormatter(LogFormatter()) for i in logging.getLogger().handlers]
def setup_logging(name):
root_logger = getLogger(name)
if PRODUCTION:
handler = MongoHandler(level=DEBUG,
collection='application-log',
**MONGOLAB_CONF_DICT)
handler.setFormatter(MongoFormatter())
else:
handler = StreamHandler()
handler.setLevel(DEBUG)
handler.setFormatter(
Formatter(
'%(asctime)s [%(process)d] [%(levelname)s/APPLICATION] %(message)s',
'%Y.%m:%d %H:%M:%S'))
root_logger.setLevel(DEBUG)
root_logger.addHandler(handler)
def update_db_logger(self, DB_CONFIG):
''' update_db_logger '''
# DB_CONFIG = conf_log.get('DB_CONFIG')
if DB_CONFIG.get('host') and DB_CONFIG.get('port'):
mdbhandler = MongoHandler(
host=DB_CONFIG['host'],
port=DB_CONFIG['port'],
database_name=DB_CONFIG.get('dbname', 'pipeline_unknown'),
collection=DB_CONFIG.get('collection', 'db_unknown'))
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(message)s')
mdbhandler.setLevel(logging.DEBUG)
logger = logging.getLogger(DB_CONFIG['name'].replace('.', '_'))
logger.addHandler(mdbhandler)
return logger
else:
raise Exception("Can't update db logger, wrong configure file")
def make_logger(name, collection='cnswd', level=logging.NOTSET):
formatter = logging.Formatter(
'%(asctime)s %(levelname)s %(name)s %(message)s')
logger = logging.Logger(name)
logger.addHandler(
MongoHandler(level=level,
host=DB_HOST,
database_name='eventlog',
collection=collection if collection else name,
fail_silently=False,
capped_max=10000,
capped=True))
ch = logging.StreamHandler()
ch.setLevel(level)
ch.setFormatter(formatter)
logger.addHandler(ch)
return logger
def __init__(self):
self.logger = logging.getLogger('logman')
self.logger.setLevel(logging.DEBUG)
self.logger.addHandler(
MongoHandler(host=os.environ['MONGO_URI'],
database_name=os.environ['MONGO_DATABASE']))
# create console handler and set level to debug
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
# create formatter
formatter = \
logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# add formatter to ch
ch.setFormatter(formatter)
# add ch to logger
self.logger.addHandler(ch)
def _get_mongo_handler(self):
components = _log_mongo_components()
# Check existence of mongo connection before creating Mongo handler
if log4mongo.handlers._connection is None:
_bootstrap_mongo_log(components)
kwargs = {
"host": compose_url(**components),
"database_name": LOG_DATABASE_NAME,
"collection": LOG_COLLECTION_NAME,
"username": components["username"],
"password": components["password"],
"capped": True,
"formatter": PypeMongoFormatter()
}
if components["port"] is not None:
kwargs["port"] = int(components["port"])
if components["auth_db"]:
kwargs["authentication_db"] = components["auth_db"]
return MongoHandler(**kwargs)
def make_log_handler(config, secret):
log_format = logging.Formatter(
"[%(asctime)s][%(filename)20s:%(lineno)4s - %(funcName)20s() ] %(message)s"
)
if config["backend"] == "file":
Path(config["path"]).parent.mkdir(parents=True, exist_ok=True)
handler = logging.FileHandler(filename=config["path"])
handler.setFormatter(log_format)
elif config["backend"] == "console":
handler = logging.StreamHandler()
handler.setFormatter(log_format)
elif config["backend"] == "mongodb":
ms = secret["mongodb"]
handler = MongoHandler(
host=ms["addr"],
port=ms["port"],
username=ms["username"],
password=ms["password"],
database_name=config["database"],
collection=config["collection"],
)
return handler
def _get_mongo_handler(cls):
cls.bootstrap_mongo_log()
if not cls.use_mongo_logging:
return
components = cls.log_mongo_url_components
kwargs = {
"host": cls.log_mongo_url,
"database_name": cls.log_database_name,
"collection": cls.log_collection_name,
"username": components["username"],
"password": components["password"],
"capped": True,
"formatter": PypeMongoFormatter()
}
if components["port"] is not None:
kwargs["port"] = int(components["port"])
if components["auth_db"]:
kwargs["authentication_db"] = components["auth_db"]
return MongoHandler(**kwargs)
def setup_handlers():
handler_id = "log4mongo_handler"
if handler_id in __opts__:
config_fields = {
"host": "host",
"port": "port",
"database_name": "database_name",
"collection": "collection",
"username": "******",
"password": "******",
"write_concern": "w",
}
config_opts = {}
for config_opt, arg_name in config_fields.items():
config_opts[arg_name] = __opts__[handler_id].get(config_opt)
config_opts["level"] = LOG_LEVELS[__opts__[handler_id].get(
"log_level", __opts__.get("log_level", "error"))]
handler = MongoHandler(formatter=FormatterWithHost(), **config_opts)
yield handler
else:
yield False
print 'logger2:'
logger2 = logging.getLogger('simple1')
logger2.debug('debug message')
logger2.info('info message')
logger2.warn('warn message')
logger2.error('error message')
logger2.critical('critical message')
import logging
from log4mongo.handlers import MongoHandler
logger = logging.getLogger('mongo_example')
mon = MongoHandler(host='localhost', database_name='db')
mon.setLevel(logging.WARNING)
ch = logging.StreamHandler()
ch.setLevel(logging.ERROR)
logger.addHandler(mon)
logger.addHandler(ch)
logger.debug('debug message')
logger.info('info message')
logger.warn('warn message')
logger.error('error message')
logger.critical('critical message')
import attrdict
from log4mongo.handlers import MongoHandler
from pymongo import MongoClient
with open("./modules/config/config.yml", 'r') as yamlfileobj:
config = attrdict.AttrDict(yaml.safe_load(yamlfileobj))
logging.basicConfig(
# datefmt='%y-%b-%d %H:%M:%S',
datefmt='%H:%M:%S',
format=
'%(levelname)8s:[%(asctime)s][%(funcName)20s()][%(lineno)4s]: %(message)s',
level=logging.DEBUG,
handlers=[
# logging.FileHandler(f'{config.dir.project}/log.log', mode='w+', encoding='utf8', delay=0),
logging.StreamHandler(),
MongoHandler(host=config.mongo.ip,
port=config.mongo.port,
username=config.mongo.username,
password=config.mongo.password,
authentication_db=config.mongo.authentication_db,
database_name='DataManager',
collection='log')
])
logger = logging.getLogger('DataGeters')
mongo_client = MongoClient(
f'mongodb://{config.mongo.username}:{config.mongo.password}@{config.mongo.ip}:{config.mongo.port}'
f'/?authSource={config.mongo.authentication_db}')
import logging
from log.RequestFormatter import RequestFormatter
from web import home
from apis.home_api import Home
app = Flask(__name__)
config = app.config
config.from_object('config')
api = Api(app)
try:
app.logger.info('mongodb get_db request complete')
environment = config['ACTIVE_ENV']
handler = MongoHandler(host=config['ENVS'][environment]['DB_HOST'],
port=config['ENVS'][environment]['DB_PORT'],
database_name=config['ENVS'][environment]['DB_NAME'])
formatter = RequestFormatter()
handler.setFormatter(formatter)
logger = logging.getLogger(config["APP_NAME"])
logger.setLevel(logging.INFO)
logger.addHandler(handler)
app.logger = logger
except pymongo.errors.ServerSelectionTimeoutError as e:
message = "Could not connect to database"
status = 403
app.logger.error('Could not connect to database',e)
except Exception as e:
message = "database connection error"
status = 400
app.logger.error('database error',e)
def get_logger(name):
logging.basicConfig(level=CONFIG['log']['level'])
logger = logging.getLogger(name)
logger.addHandler(
MongoHandler(host=CONFIG['db']['ip'], capped=CONFIG['log']['capped']))
return logger
def get_mongo_logger():
mongo_logger = logging.getLogger('hm_logger')
if not len(mongo_logger.handlers):
mongo_logger.addHandler(MongoHandler(host=MONGO_HOST, username = MONGO_USER, password = MONGO_PWD))
mongo_logger.setLevel(logging.DEBUG)
return mongo_logger
def test_connect_failed(self):
with self.assertRaises(AutoReconnect):
MongoHandler(host='unknow_host',
database_name=self.database_name,
collection=self.collection_name)
import logging
from log4mongo.handlers import MongoHandler
from . import logging_level
"""
https://docs.python.org/3.6/library/logging.html
"""
LEVEL_DICT = {
'CRITICAL': logging.CRITICAL, # 50
'ERROR': logging.ERROR, # 40
'WARNING': logging.WARNING, # 30
'INFO': logging.INFO, # 20
'DEBUG': logging.DEBUG, # 10
'NOTSET': logging.NOTSET # 0
}
logger = logging.getLogger('doutorfacil')
logger.setLevel(LEVEL_DICT[logging_level])
logger.addHandler(MongoHandler(host='localhost'))
import hmac
import json
import logging
import smtplib
import threading
from email.mime.text import MIMEText
import Pyro4
import time
import zlib
from log4mongo.handlers import MongoHandler
# === PYTHON LOGGER ===
logger = logging.getLogger("app2")
handler = MongoHandler(host='localhost',
database_name='db_group4',
collection='log_group4',
port=27017)
logger.addHandler(handler)
FORMAT = '[%(asctime)s][%(levelname)s][%(module)s][%(funcName)s][line:%(lineno)d] %(message)s'
datestr = "%m/%d/%Y %I:%M:%S %p"
logging.basicConfig(format=FORMAT, datefmt=datestr, level=logging.DEBUG)
class App3:
def __init__(self):
self.__from_address = '*****@*****.**'
self.__to_addresses = ['*****@*****.**']
self.__subject = 'TEAM 4'
def email_payload(self, i, body, subject, to_address, from_address):
"""
# coding: utf-8
import logging
from logging.config import fileConfig
fileConfig('logger_config.conf')
from log4mongo.handlers import MongoHandler
logger = logging.getLogger()
mon = MongoHandler(host='121.42.33.117', database_name='mongo_logs')
logger.addHandler(mon)
def main():
# logger.debug('I am here!')
logger.debug('I am here!')
logger.error('I am here!')
if __name__ == '__main__':
main()
