def test_disable_tracing_url_default(self):
url = 'http://127.0.0.1:8080/_ah/health'
disable_tracing = utils.disable_tracing_url(url)
self.assertTrue(disable_tracing)
url = 'http://127.0.0.1:8080/mysql'
disable_tracing = utils.disable_tracing_url(url)
self.assertFalse(disable_tracing)
def _teardown_request(self, exception):
# Do not trace if the url is blacklisted
if utils.disable_tracing_url(flask.request.url, self.blacklist_paths):
return
try:
tracer = execution_context.get_opencensus_tracer()
if exception is not None:
span = execution_context.get_current_span()
span.status = status.Status(
code=code_pb2.UNKNOWN,
message=str(exception)
)
# try attaching the stack trace to the span, only populated if
# the app has 'PROPAGATE_EXCEPTIONS', 'DEBUG', or 'TESTING'
# enabled
exc_type, _, exc_traceback = sys.exc_info()
if exc_traceback is not None:
span.stack_trace = stack_trace.StackTrace.from_traceback(
exc_traceback
)
tracer.end_span()
tracer.finish()
except Exception: # pragma: NO COVER
log.error('Failed to trace request', exc_info=True)
def _before_request(self):
"""A function to be run before each request.
See: http://flask.pocoo.org/docs/0.12/api/#flask.Flask.before_request
"""
# Do not trace if the url is blacklisted
if utils.disable_tracing_url(flask.request.url, self.blacklist_paths):
return
try:
span_context = self.propagator.from_headers(flask.request.headers)
tracer = tracer_module.Tracer(
span_context=span_context,
sampler=self.sampler,
exporter=self.exporter,
propagator=self.propagator)
span = tracer.start_span()
span.span_kind = span_module.SpanKind.SERVER
# Set the span name as the name of the current module name
span.name = '[{}]{}'.format(
flask.request.method,
flask.request.url)
tracer.add_attribute_to_current_span(
HTTP_METHOD, flask.request.method)
tracer.add_attribute_to_current_span(
HTTP_URL, str(flask.request.url))
execution_context.set_opencensus_attr(
'blacklist_hostnames',
self.blacklist_hostnames)
except Exception: # pragma: NO COVER
log.error('Failed to trace request', exc_info=True)
def _execute(func, handler, args, kwargs):
with tracer_stack_context():
config = handler.settings.get(CONFIG_KEY, None)
if not config or utils.disable_tracing_url(
handler.request.path, config.get(BLACKLIST_PATHS, None)):
tracer = NoopTracer()
setattr(handler.request, TRACER, tracer)
return func(*args, **kwargs)
propagator = config[PROPAGATOR_KEY]
span_context = propagator.from_headers(handler.request.headers)
tracer = tracer_module.Tracer(span_context=span_context,
sampler=config[SAMPLER_KEY],
exporter=config[EXPORTER_KEY],
propagator=propagator)
setattr(handler.request, TRACER, tracer)
span = tracer.start_span()
span.name = '[{}]{}'.format(_get_class_name(handler),
handler.request.method)
span.span_kind = span_module.SpanKind.SERVER
tracer.add_attribute_to_current_span(
attribute_key=HTTP_METHOD, attribute_value=handler.request.method)
tracer.add_attribute_to_current_span(
attribute_key=HTTP_URL, attribute_value=handler.request.path)
return func(*args, **kwargs)
def _before_request(self, request):
if utils.disable_tracing_url(request.path, self._blacklist_paths):
return
try:
span_context = self.propagator.from_headers(request.headers)
tracer = tracer_module.Tracer(
span_context=span_context,
sampler=self.sampler,
exporter=self.exporter,
propagator=self.propagator)
span = tracer.start_span()
# Set the span name as the name of the current module name
span.name = '[{}]{}'.format(
request.method,
request.path)
tracer.add_attribute_to_current_span(
attribute_key=HTTP_METHOD,
attribute_value=request.method)
tracer.add_attribute_to_current_span(
attribute_key=HTTP_URL,
attribute_value=request.path)
except Exception: # pragma: NO COVER
log.error('Failed to trace request', exc_info=True)
def process_request(self, request):
"""Called on each request, before Django decides which view to execute.
:type request: :class:`~django.http.request.HttpRequest`
:param request: Django http request.
"""
# Do not trace if the url is blacklisted
if utils.disable_tracing_url(request.path, self._blacklist_paths):
return
# Add the request to thread local
execution_context.set_opencensus_attr(REQUEST_THREAD_LOCAL_KEY,
request)
try:
# Start tracing this request
span_context = self.propagator.from_headers(
_DjangoMetaWrapper(_get_django_request().META))
# Reload the tracer with the new span context
tracer = tracer_module.Tracer(span_context=span_context,
sampler=self.sampler,
exporter=self.exporter,
propagator=self.propagator)
# Span name is being set at process_view
span = tracer.start_span()
span.span_kind = span_module.SpanKind.SERVER
tracer.add_attribute_to_current_span(
attribute_key=HTTP_METHOD, attribute_value=request.method)
tracer.add_attribute_to_current_span(attribute_key=HTTP_URL,
attribute_value=request.path)
except Exception: # pragma: NO COVER
log.error('Failed to trace request', exc_info=True)
def do_trace_request(self, request):
if utils.disable_tracing_url(request.url, self.blacklist_paths):
return
span_context = self.propagator.from_headers(request.headers)
tracer = noop_tracer_module.NoopTracer()
if span_context.from_header and span_context.trace_options.enabled:
tracer = tracer_module.ContextTracer(span_context=span_context,
exporter=self.exporter)
elif self.sampler.should_sample(span_context.trace_id):
tracer = tracer_module.ContextTracer(exporter=self.exporter)
span = tracer.start_span()
route = request.app.router.get(request)
# Set the span name as the name of the current module name
span.name = '[sanic] {} {}'.format(request.method, route[3])
tracer.add_attribute_to_current_span('http.nethod', request.method)
tracer.add_attribute_to_current_span('http.host', request.host)
tracer.add_attribute_to_current_span('http.scheme', request.scheme)
tracer.add_attribute_to_current_span('http.url', request.url)
tracer.add_attribute_to_current_span('http.client.ip', request.ip)
for header in ['user-agent', 'x-forwarded-for', 'x-real-ip']:
if header in request.headers:
tracer.add_attribute_to_current_span('http.headers.' + header,
request.headers[header])
request['tracer'] = tracer
asyncio_context.set_opencensus_tracer(tracer)
def test_blacklist_path(self):
from django.test import RequestFactory
from opencensus.trace.ext.django import middleware
from opencensus.trace.tracers import base
from opencensus.trace.tracers import noop_tracer
from opencensus.trace.ext import utils
from opencensus.trace import execution_context
execution_context.clear()
blacklist_paths = [
'test_blacklist_path',
]
params = {
'BLACKLIST_PATHS': [
'test_blacklist_path',
],
'TRANSPORT':
'opencensus.trace.exporters.transports.sync.SyncTransport',
}
patch_params = mock.patch(
'opencensus.trace.ext.django.middleware.settings.params', params)
with patch_params:
middleware_obj = middleware.OpencensusMiddleware()
django_request = RequestFactory().get('/test_blacklist_path')
disabled = utils.disable_tracing_url(django_request.path,
blacklist_paths)
self.assertTrue(disabled)
self.assertEqual(middleware_obj._blacklist_paths, blacklist_paths)
# test process_request
middleware_obj.process_request(django_request)
tracer = middleware._get_current_tracer()
span = tracer.current_span()
# process view
view_func = mock.Mock()
middleware_obj.process_view(django_request, view_func)
tracer = middleware._get_current_tracer()
span = tracer.current_span()
assert isinstance(span, base.NullContextManager)
# process response
django_response = mock.Mock()
django_response.status_code = 200
middleware_obj.process_response(django_request, django_response)
tracer = middleware._get_current_tracer()
span = tracer.current_span()
assert isinstance(span, base.NullContextManager)
def _after_request(self, request, response):
if utils.disable_tracing_url(request.path, self._blacklist_paths):
return
try:
tracer = execution_context.get_opencensus_tracer()
tracer.add_attribute_to_current_span(HTTP_STATUS_CODE,
str(response.status_code))
tracer.end_span()
tracer.finish()
except Exception: # pragma: NO COVER
log.error('Failed to trace request', exc_info=True)
def process_view(self, request, view_func, *args, **kwargs):
"""Process view is executed before the view function, here we get the
function name add set it as the span name.
"""
# Do not trace if the url is blacklisted
if utils.disable_tracing_url(request.path, self._blacklist_paths):
return
try:
# Get the current span and set the span name to the current
# function name of the request.
tracer = _get_current_tracer()
span = tracer.current_span()
span.name = utils.get_func_name(view_func)
except Exception: # pragma: NO COVER
log.error('Failed to trace request', exc_info=True)
def _after_request(self, response):
"""A function to be run after each request.
See: http://flask.pocoo.org/docs/0.12/api/#flask.Flask.after_request
"""
# Do not trace if the url is blacklisted
if utils.disable_tracing_url(flask.request.url, self.blacklist_paths):
return response
try:
tracer = execution_context.get_opencensus_tracer()
tracer.add_attribute_to_current_span(HTTP_STATUS_CODE,
str(response.status_code))
except Exception: # pragma: NO COVER
log.error('Failed to trace request', exc_info=True)
finally:
return response
def do_trace_response(self, request, response):
"""A function to be run after each request.
"""
# Do not trace if the url is blacklisted
if utils.disable_tracing_url(request.url, self.blacklist_paths):
return
if 'tracer' not in request:
return
tracer = request['tracer']
tracer.add_attribute_to_current_span('http.status_code',
str(response.status))
if response.status >= 500:
tracer.add_attribute_to_current_span('error', True)
tracer.end_span()
tracer.finish()
def process_response(self, request, response):
# Do not trace if the url is blacklisted
if utils.disable_tracing_url(request.path, self._blacklist_paths):
return response
try:
span = _get_django_span()
span.add_attribute(attribute_key=HTTP_STATUS_CODE,
attribute_value=str(response.status_code))
_set_django_attributes(span, request)
tracer = _get_current_tracer()
tracer.end_span()
tracer.finish()
except Exception: # pragma: NO COVER
log.error('Failed to trace request', exc_info=True)
finally:
return response
def test_disable_tracing_url_explicit(self):
url = 'http://127.0.0.1:8080/test_no_tracing'
blacklist_paths = ['test_no_tracing']
disable_tracing = utils.disable_tracing_url(url, blacklist_paths)
self.assertTrue(disable_tracing)
