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_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 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): """