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 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 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 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)
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(self):
log = logging.getLogger('testLogger')
handler = MongoHandler(host='localhost', database_name=self.db_name, collection=self.cl_name)
log.addHandler(handler)
log.warning('test message')
document = handler.collection.find_one({'message': 'test message', 'level': 'WARNING'})
self.assertEquals(document['message'], 'test message')
self.assertEquals(document['level'], 'WARNING')
handler.close()
log.removeHandler(handler)
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 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 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 test_logger_name(self):
log = logging.getLogger('testLogger')
handler = MongoHandler(host='localhost', database_name=self.db_name, collection=self.cl_name, logger_name='meh')
log.addHandler(handler)
try:
raise Exception('exc1')
except:
log.exception('test message')
document = handler.collection.find_one({'message': 'test message', 'level': 'ERROR'})
self.assertEquals(document['loggerName'], 'meh')
handler.close()
log.removeHandler(handler)
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_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 setUp(self):
self.handler = MongoHandler(host=self.host_name, database_name=self.database_name, collection=self.collection_name)
self.log = logging.getLogger('testLogger')
self.log.setLevel(logging.DEBUG)
self.log.addHandler(self.handler)
self.old_stderr = sys.stdout
sys.stderr = StringIO()
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 _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 __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 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 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 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 __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 __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 __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 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 __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 _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
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
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_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)
class TestMongoHandler(unittest.TestCase):
host_name = 'localhost'
database_name = 'log4mongo_test'
collection_name = 'logs_test'
def setUp(self):
self.handler = MongoHandler(host=self.host_name,
database_name=self.database_name,
collection=self.collection_name)
self.log = logging.getLogger('testLogger')
self.log.setLevel(logging.DEBUG)
self.log.addHandler(self.handler)
self.old_stderr = sys.stdout
sys.stderr = StringIO()
def tearDown(self):
self.handler.connection.drop_database(self.database_name)
self.handler.close()
self.log.removeHandler(self.handler)
self.log = None
self.handler = None
sys.stderr.close()
sys.stderr = self.old_stderr
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 test_connect_failed(self):
with self.assertRaises(AutoReconnect):
MongoHandler(host='unknow_host',
database_name=self.database_name,
collection=self.collection_name)
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 test_emit(self):
self.log.warning('test message')
document = self.handler.collection.find_one({
'message': 'test message',
'level': 'WARNING'
})
self.assertEqual(document['message'], 'test message')
self.assertEqual(document['level'], 'WARNING')
def test_emit_exception(self):
try:
raise Exception('exc1')
except:
self.log.exception('test message')
document = self.handler.collection.find_one({
'message': 'test message',
'level': 'ERROR'
})
self.assertEqual(document['message'], 'test message')
self.assertEqual(document['level'], 'ERROR')
self.assertEqual(document['exception']['message'], 'exc1')
def test_emit_fail(self):
self.handler.collection = ''
self.log.warn('test warning')
self.assertRegexpMatches(
sys.stderr.getvalue(),
r"AttributeError: 'str' object has no attribute 'save'")
def test_email_fail_silent(self):
self.handler.fail_silently = True
self.handler.collection = ''
self.log.warn('test warming')
self.assertEqual(sys.stderr.getvalue(), '')
def test_contextual_info(self):
self.log.info('test message with contextual info',
extra={
'ip': '127.0.0.1',
'host': 'localhost'
})
document = self.handler.collection.find_one({
'message': 'test message with contextual info',
'level': 'INFO'
})
self.assertEqual(document['message'],
'test message with contextual info')
self.assertEqual(document['level'], 'INFO')
self.assertEqual(document['ip'], '127.0.0.1')
self.assertEqual(document['host'], 'localhost')
def test_contextual_info_adapter(self):
adapter = logging.LoggerAdapter(self.log, {
'ip': '127.0.0.1',
'host': 'localhost'
})
adapter.info('test message with contextual info')
document = self.handler.collection.find_one({
'message': 'test message with contextual info',
'level': 'INFO'
})
self.assertEqual(document['message'],
'test message with contextual info')
self.assertEqual(document['level'], 'INFO')
self.assertEqual(document['ip'], '127.0.0.1')
self.assertEqual(document['host'], 'localhost')
# 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()
class TestMongoHandler(unittest.TestCase):
host_name = 'localhost'
database_name = 'log4mongo_test'
collection_name = 'logs_test'
def setUp(self):
self.handler = MongoHandler(host=self.host_name, database_name=self.database_name, collection=self.collection_name)
self.log = logging.getLogger('testLogger')
self.log.setLevel(logging.DEBUG)
self.log.addHandler(self.handler)
self.old_stderr = sys.stdout
sys.stderr = StringIO()
def tearDown(self):
self.handler.connection.drop_database(self.database_name)
self.handler.close()
self.log.removeHandler(self.handler)
self.log = None
self.handler = None
sys.stderr.close()
sys.stderr = self.old_stderr
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 test_connect_failed(self):
with self.assertRaises(AutoReconnect):
MongoHandler(host='unknow_host', database_name=self.database_name, collection=self.collection_name)
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 test_emit(self):
self.log.warning('test message')
document = self.handler.collection.find_one({'message': 'test message', 'level': 'WARNING'})
self.assertEqual(document['message'], 'test message')
self.assertEqual(document['level'], 'WARNING')
def test_emit_exception(self):
try:
raise Exception('exc1')
except:
self.log.exception('test message')
document = self.handler.collection.find_one({'message': 'test message', 'level': 'ERROR'})
self.assertEqual(document['message'], 'test message')
self.assertEqual(document['level'], 'ERROR')
self.assertEqual(document['exception']['message'], 'exc1')
def test_emit_fail(self):
self.handler.collection = ''
self.log.warn('test warning')
self.assertRegexpMatches(sys.stderr.getvalue(), r"AttributeError: 'str' object has no attribute 'save'")
def test_email_fail_silent(self):
self.handler.fail_silently = True
self.handler.collection = ''
self.log.warn('test warming')
self.assertEqual(sys.stderr.getvalue(), '')
def test_contextual_info(self):
self.log.info('test message with contextual info', extra={'ip': '127.0.0.1', 'host': 'localhost'})
document = self.handler.collection.find_one({'message': 'test message with contextual info', 'level': 'INFO'})
self.assertEqual(document['message'], 'test message with contextual info')
self.assertEqual(document['level'], 'INFO')
self.assertEqual(document['ip'], '127.0.0.1')
self.assertEqual(document['host'], 'localhost')
def test_contextual_info_adapter(self):
adapter = logging.LoggerAdapter(self.log, {'ip': '127.0.0.1', 'host': 'localhost'})
adapter.info('test message with contextual info')
document = self.handler.collection.find_one({'message': 'test message with contextual info', 'level': 'INFO'})
self.assertEqual(document['message'], 'test message with contextual info')
self.assertEqual(document['level'], 'INFO')
self.assertEqual(document['ip'], '127.0.0.1')
self.assertEqual(document['host'], 'localhost')
def test_emit_fail(self):
log = logging.getLogger('testLogger')
handler = MongoHandler(host='localhost', database_name=self.db_name, collection='meh',
fail_silently=True)
log.addHandler(handler)
try:
log.warning('test message')
except Exception, e:
self.fail("Logger shouldn't raise Exceptions (%s) while fail_silently is True." % e)
handler.close()
log.removeHandler(handler)
handler = MongoHandler(host='localhost', database_name=self.db_name, collection='meh',
fail_silently=False)
log.addHandler(handler)
try:
log.warning('test message')
self.fail("Logger should raise Exceptions while fail_silently is False.")
except Exception, e:
assert True
handler.close()
log.removeHandler(handler)
def tearDown(self):
handler = MongoHandler(host='localhost', database_name=self.db_name, collection=self.cl_name)
handler.connection.drop_database(self.db_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)
class TestMongoHandler(unittest.TestCase):
host_name = 'localhost'
database_name = 'log4mongo_test'
collection_name = 'logs_test'
def setUp(self):
self.handler = MongoHandler(host=self.host_name,
database_name=self.database_name,
collection=self.collection_name,
)
self.log = logging.getLogger('testLogger')
self.log.setLevel(logging.DEBUG)
self.log.addHandler(self.handler)
self.old_stderr = sys.stdout
sys.stderr = StringIO()
def tearDown(self):
self.handler.connection.drop_database(self.database_name)
self.handler.close()
self.log.removeHandler(self.handler)
self.log = None
self.handler = None
sys.stderr.close()
sys.stderr = self.old_stderr
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 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 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 test_emit(self):
self.log.warning('test message')
document = self.handler.collection.find_one(
{'message': 'test message', 'level': 'WARNING'})
self.assertEqual(document['message'], 'test message')
self.assertEqual(document['level'], 'WARNING')
def test_emit_exception(self):
try:
raise Exception('exc1')
except:
self.log.exception('test message')
document = self.handler.collection.find_one(
{'message': 'test message', 'level': 'ERROR'})
self.assertEqual(document['message'], 'test message')
self.assertEqual(document['level'], 'ERROR')
self.assertEqual(document['exception']['message'], 'exc1')
def test_emit_fail(self):
self.handler.collection = ''
self.log.warning('test warning')
val = sys.stderr.getvalue()
self.assertRegexpMatches(val, r"AttributeError: 'str' object has no attribute '{}'".format(write_method))
def test_email_fail_silent(self):
self.handler.fail_silently = True
self.handler.collection = ''
self.log.warning('test warming')
self.assertEqual(sys.stderr.getvalue(), '')
def test_contextual_info(self):
self.log.info('test message with contextual info',
extra={'ip': '127.0.0.1', 'host': 'localhost'})
document = self.handler.collection.find_one(
{'message': 'test message with contextual info', 'level': 'INFO'})
self.assertEqual(document['message'],
'test message with contextual info')
self.assertEqual(document['level'], 'INFO')
self.assertEqual(document['ip'], '127.0.0.1')
self.assertEqual(document['host'], 'localhost')
def test_contextual_info_adapter(self):
adapter = logging.LoggerAdapter(self.log,
{'ip': '127.0.0.1',
'host': 'localhost'})
adapter.info('test message with contextual info')
document = self.handler.collection.find_one({'message': 'test message with contextual info', 'level': 'INFO'})
self.assertEqual(document['message'], 'test message with contextual info')
self.assertEqual(document['level'], 'INFO')
self.assertEqual(document['ip'], '127.0.0.1')
self.assertEqual(document['host'], 'localhost')
# mongo logger, only logs the tweets, modified from log4Mongo
class ExtraOnlyFormatter(logging.Formatter):
def format(self, record):
""" Formats tweet into python dictionary."""
return record.tweet
class InfoOnlyFilter(logging.Filter):
def filter(self, record):
return record.levelname == "INFO" and hasattr(record, "tweet")
from log4mongo.handlers import MongoHandler
mongoHandler = MongoHandler(host="localhost", database_name="busfumes", collection="tweets")
mongoHandler.setFormatter(ExtraOnlyFormatter())
mongoHandler.addFilter(InfoOnlyFilter())
# add formatter
formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
timedHandler.setFormatter(formatter)
ch.setFormatter(formatter)
# add handlers
logger.addHandler(timedHandler)
logger.addHandler(ch)
logger.addHandler(mongoHandler)
############## start scripts
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'))
class TestMongoHandler(unittest.TestCase):
host_name = 'localhost'
database_name = 'log4mongo_test'
collection_name = 'logs_test'
def setUp(self):
self.handler = MongoHandler(
host=self.host_name,
database_name=self.database_name,
collection=self.collection_name,
)
self.log = logging.getLogger('testLogger')
self.log.setLevel(logging.DEBUG)
self.log.addHandler(self.handler)
self.old_stderr = sys.stdout
sys.stderr = StringIO()
def tearDown(self):
self.handler.connection.drop_database(self.database_name)
self.handler.close()
self.log.removeHandler(self.handler)
self.log = None
self.handler = None
sys.stderr.close()
sys.stderr = self.old_stderr
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 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 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 test_emit(self):
self.log.warning('test message')
document = self.handler.collection.find_one({
'message': 'test message',
'level': 'WARNING'
})
self.assertEqual(document['message'], 'test message')
self.assertEqual(document['level'], 'WARNING')
def test_emit_exception(self):
try:
raise Exception('exc1')
except:
self.log.exception('test message')
document = self.handler.collection.find_one({
'message': 'test message',
'level': 'ERROR'
})
self.assertEqual(document['message'], 'test message')
self.assertEqual(document['level'], 'ERROR')
self.assertEqual(document['exception']['message'], 'exc1')
def test_emit_fail(self):
self.handler.collection = ''
self.log.warning('test warning')
val = sys.stderr.getvalue()
self.assertRegexpMatches(
val, r"AttributeError: 'str' object has no attribute '{}'".format(
write_method))
def test_email_fail_silent(self):
self.handler.fail_silently = True
self.handler.collection = ''
self.log.warning('test warming')
self.assertEqual(sys.stderr.getvalue(), '')
def test_contextual_info(self):
self.log.info('test message with contextual info',
extra={
'ip': '127.0.0.1',
'host': 'localhost'
})
document = self.handler.collection.find_one({
'message': 'test message with contextual info',
'level': 'INFO'
})
self.assertEqual(document['message'],
'test message with contextual info')
self.assertEqual(document['level'], 'INFO')
self.assertEqual(document['ip'], '127.0.0.1')
self.assertEqual(document['host'], 'localhost')
def test_contextual_info_adapter(self):
adapter = logging.LoggerAdapter(self.log, {
'ip': '127.0.0.1',
'host': 'localhost'
})
adapter.info('test message with contextual info')
document = self.handler.collection.find_one({
'message': 'test message with contextual info',
'level': 'INFO'
})
self.assertEqual(document['message'],
'test message with contextual info')
self.assertEqual(document['level'], 'INFO')
self.assertEqual(document['ip'], '127.0.0.1')
self.assertEqual(document['host'], 'localhost')
def tearDown(self):
handler = MongoHandler(host='localhost', database_name=self.db_name, collection=self.cl_name)
handler.connection.drop_database(self.db_name)
handler.close()
class TestMongoHandler(unittest.TestCase):
host_name = "localhost"
database_name = "log4mongo_test"
collection_name = "logs_test"
def setUp(self):
self.handler = MongoHandler(
host=self.host_name, database_name=self.database_name, collection=self.collection_name
)
self.log = logging.getLogger("testLogger")
self.log.setLevel(logging.DEBUG)
self.log.addHandler(self.handler)
self.old_stderr = sys.stdout
sys.stderr = StringIO()
def tearDown(self):
self.handler.connection.drop_database(self.database_name)
self.handler.close()
self.log.removeHandler(self.handler)
self.log = None
self.handler = None
sys.stderr.close()
sys.stderr = self.old_stderr
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 test_connect_failed(self):
with self.assertRaises(PyMongoError):
MongoHandler(host="unknow_host", database_name=self.database_name, collection=self.collection_name)
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 test_emit(self):
self.log.warning("test message")
document = self.handler.collection.find_one({"message": "test message", "level": "WARNING"})
self.assertEqual(document["message"], "test message")
self.assertEqual(document["level"], "WARNING")
def test_emit_exception(self):
try:
raise Exception("exc1")
except:
self.log.exception("test message")
document = self.handler.collection.find_one({"message": "test message", "level": "ERROR"})
self.assertEqual(document["message"], "test message")
self.assertEqual(document["level"], "ERROR")
self.assertEqual(document["exception"]["message"], "exc1")
def test_emit_fail(self):
self.handler.collection = ""
self.log.warn("test warning")
self.assertRegexpMatches(sys.stderr.getvalue(), r"AttributeError: 'str' object has no attribute 'save'")
def test_email_fail_silent(self):
self.handler.fail_silently = True
self.handler.collection = ""
self.log.warn("test warming")
self.assertEqual(sys.stderr.getvalue(), "")
def test_contextual_info(self):
self.log.info("test message with contextual info", extra={"ip": "127.0.0.1", "host": "localhost"})
document = self.handler.collection.find_one({"message": "test message with contextual info", "level": "INFO"})
self.assertEqual(document["message"], "test message with contextual info")
self.assertEqual(document["level"], "INFO")
self.assertEqual(document["ip"], "127.0.0.1")
self.assertEqual(document["host"], "localhost")
def test_contextual_info_adapter(self):
adapter = logging.LoggerAdapter(self.log, {"ip": "127.0.0.1", "host": "localhost"})
adapter.info("test message with contextual info")
document = self.handler.collection.find_one({"message": "test message with contextual info", "level": "INFO"})
self.assertEqual(document["message"], "test message with contextual info")
self.assertEqual(document["level"], "INFO")
self.assertEqual(document["ip"], "127.0.0.1")
self.assertEqual(document["host"], "localhost")
#!/usr/local/bin/python
# -*- coding: utf-8 -*-
import logging
from log4mongo.handlers import MongoHandler
logger = logging.getLogger('mongo_example')
mon = MongoHandler(host='localhost', database_name='mongo_logs')
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 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):
"""
