def test_logging_handler_emit_error(capsys, elasticapm_client): handler = LoggingHandler(elasticapm_client) handler._emit = lambda: 1 / 0 handler.emit(LogRecord("x", 1, "/ab/c/", 10, "Oops", [], None)) out, err = capsys.readouterr() assert "Top level ElasticAPM exception caught" in err assert "Oops" in err
def test_logger_setup(): handler = LoggingHandler(server_url="foo", service_name="bar", secret_token="baz") client = handler.client assert client.config.server_url == "foo" assert client.config.service_name == "bar" assert client.config.secret_token == "baz" assert handler.level == logging.NOTSET
def setUp(self): self.client = get_tempstoreclient( include_paths=['tests', 'elasticapm']) self.handler = LoggingHandler(self.client) self.logger = logging.getLogger(__name__) self.logger.handlers = [] self.logger.addHandler(self.handler)
def logger(elasticapm_client): elasticapm_client.config.include_paths = ["tests", "elasticapm"] handler = LoggingHandler(elasticapm_client) logger = logging.getLogger(__name__) logger.handlers = [] logger.addHandler(handler) logger.client = elasticapm_client logger.level = logging.INFO return logger
def test_logger_setup(): handler = LoggingHandler( server_url="foo", service_name="bar", secret_token="baz", metrics_interval="0ms", client_cls=TempStoreClient ) client = handler.client assert client.config.server_url == "foo" assert client.config.service_name == "bar" assert client.config.secret_token == "baz" assert handler.level == logging.NOTSET
def test_logging_handler_no_client(recwarn): # In 6.0, this should be changed to expect a ValueError instead of a log warnings.simplefilter("always") LoggingHandler() while True: # If we never find our desired warning this will eventually throw an # AssertionError w = recwarn.pop(PendingDeprecationWarning) if "LoggingHandler requires a Client instance" in w.message.args[0]: return True
def init_app(self, app, *args, **kwargs): super().init_app(app, service_name=app.config.get('APP_NAME', 'app'), server_url=app.config.get('APM_SERVER_URL', 'http://apm:8200'), logging=True, debug=True, capture_body='all') handler = LoggingHandler(client=self.client) handler.setLevel(logging.DEBUG) app.logger.addHandler(handler) self.is_initialized = True @app.before_request def apm_user_context(): # importing over here as it won't work outside request context from flask import request initiator = request.headers.get('X-Initiator') if initiator: set_user_context(user_id=initiator)
async def wrapper(*args, **kwargs): try: instrument() client = Client() handler = LoggingHandler() logger = logging.getLogger() logger.addHandler(handler) client.begin_transaction(tran_category) result = await func(*args, **kwargs) client.end_transaction(tran_name, ok_status) return result except Exception as e: logging.error(e, exc_info=True) client.end_transaction(tran_name, error_status) raise
def __init__(self, media_type=DEFAULT_MEDIA_TYPE, request_type=Request, response_type=Response, middleware=None, router=None, independent_middleware=False): self.apm_client = get_client() if self.apm_client: logging_level = getattr(settings, 'API_LOG_LEVEL', 'DEBUG') setup_logging(LoggingHandler(self.apm_client, level=logging_level)) if self.apm_client.config.instrument: elasticapm.instrumentation.control.instrument() middleware.insert(0, middlewares.TraceMiddleware(self.apm_client)) super().__init__(media_type=media_type, request_type=request_type, response_type=response_type, middleware=middleware, router=router, independent_middleware=independent_middleware)
def init_app(self, app): self.app = app if not self.client: self.client = make_client( self.client_cls, app, self.app_name, self.secret_token, ) if self.logging: setup_logging(LoggingHandler(self.client)) signals.got_request_exception.connect(self.handle_exception, sender=app, weak=False) try: from elasticapm.contrib.celery import register_exception_tracking register_exception_tracking(self.client) except ImportError: pass # Instrument to get traces skip_env_var = 'SKIP_INSTRUMENT' if skip_env_var in os.environ: logger.debug("Skipping instrumentation. %s is set.", skip_env_var) else: elasticapm.instrumentation.control.instrument() signals.request_started.connect(self.request_started, sender=app) signals.request_finished.connect(self.request_finished, sender=app) try: from elasticapm.contrib.celery import register_instrumentation register_instrumentation(self.client) except ImportError: pass
for i in range(1, 10): try: 1 / 0 except ZeroDivisionError: app.logger.error('Breninho is hereeeee', exc_info=True, extra={ 'am_i_agent_breno': True, }) try: a = [1, 2, 3] print a[4] except IndexError: app.logger.error('Breno is here', exc_info=True, extra={ 'am_i_agent_breno': True, }) return {'Heeeeeey': 'Im generating a lot of error to you'} api.add_resource(ElasticBrenoResource, '/error') if __name__ == '__main__': handler = LoggingHandler(client=apm.client) handler.setLevel('WARN') app.logger.addHandler(handler) app.run(host='0.0.0.0', port=9999, debug=True)
def test_client_kwarg(self): client = get_tempstoreclient(include_paths=['tests']) handler = LoggingHandler(client=client) self.assertEquals(handler.client, client)
# Configure logging if os.environ['ELASTIC_APM_SERVICE_NAME'] and os.environ[ 'ELASTIC_APM_SERVER_URL']: # configure to use ELASTIC_APM in your application's settings from elasticapm.contrib.flask import ElasticAPM app.config['ELASTIC_APM'] = { # allowed app_name chars: a-z, A-Z, 0-9, -, _, and space from elasticapm.contrib.flask 'APP_NAME': os.environ['ELASTIC_APM_SERVICE_NAME'], # 'SECRET_TOKEN': 'yourToken', #if you set on the APM server configuration 'SERVER_URL': os.environ['ELASTIC_APM_SERVER_URL'] # your APM server url } apm = ElasticAPM(app) handler = LoggingHandler(client=apm.client) handler.setLevel(logging.WARN) app.logger.addHandler(handler) # Example usage: # app.logger.error('Failed to send: Invalid number', # exc_info=True, # extra={ # 'uid': uid # }) logger = log_manager.get_logger('api_manager') @app.route("/ping") def ping():
@app.route('/bar') def bar_route(): return bar() @elasticapm.capture_span() def bar(): extra() return "bar" @elasticapm.capture_span() def extra(): return "extra" @app.route('/oof') def oof_route(): raise Exception('oof') if __name__ == '__main__': app.run(host='0.0.0.0', port=int(os.environ['FLASK_PORT'])) # Create a logging handler and attach it. handler = LoggingHandler(client=apm.client) handler.setLevel(logging.INFO) app.logger.addHandler(handler)