def init_app(self, app, **defaults):
self.app = app
if not self.client:
self.client = make_client(self.client_cls, app, **defaults)
# 0 is a valid log level (NOTSET), so we need to check explicitly for it
if self.logging or self.logging is 0:
if self.logging is not True:
kwargs = {"level": self.logging}
else:
kwargs = {}
setup_logging(LoggingHandler(self.client, **kwargs))
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 spans
if self.client.config.instrument:
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
else:
logger.debug(
"Skipping instrumentation. INSTRUMENT is set to False.")
@app.context_processor
def rum_tracing():
"""
Adds APM related IDs to the context used for correlating the backend transaction with the RUM transaction
"""
transaction = get_transaction()
if transaction and transaction.trace_parent:
return {
"apm": {
"trace_id":
transaction.trace_parent.trace_id,
"span_id":
lambda: transaction.ensure_parent_id(),
"is_sampled":
transaction.is_sampled,
"is_sampled_js":
"true" if transaction.is_sampled else "false",
}
}
return {}
def init_app(self, app, **defaults):
self.app = app
if not self.client:
self.client = make_client(self.client_cls, app, **defaults)
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 spans
if self.client.config.instrument:
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
else:
logger.debug(
"Skipping instrumentation. INSTRUMENT is set to False.")
def test_basic_already_configured():
with mock.patch("logging.getLogger", spec=logging.getLogger) as getLogger:
handler = mock.Mock()
logger = getLogger()
logger.handlers = [handler]
result = setup_logging(handler)
assert not result
def test_basic_not_configured():
with mock.patch("logging.getLogger", spec=logging.getLogger) as getLogger:
logger = getLogger()
logger.handlers = []
handler = mock.Mock()
result = setup_logging(handler)
assert result
def test_basic_already_configured(self):
with mock.patch('logging.getLogger',
spec=logging.getLogger) as getLogger:
handler = mock.Mock()
logger = getLogger()
logger.handlers = [handler]
result = setup_logging(handler)
self.assertFalse(result)
def test_basic_not_configured(self):
with mock.patch('logging.getLogger',
spec=logging.getLogger) as getLogger:
logger = getLogger()
logger.handlers = []
handler = mock.Mock()
result = setup_logging(handler)
self.assertTrue(result)
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
