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)