def test_200_query_string(self):
# ensure query string is removed before adding url to metadata
query_string = "key=value&key2=value2"
with self.override_http_config("requests", dict(trace_query_string=True)):
out = self.session.get(URL_200 + "?" + query_string)
assert out.status_code == 200
# validation
spans = self.pop_spans()
assert len(spans) == 1
s = spans[0]
assert_is_measured(s)
assert s.get_tag(http.METHOD) == "GET"
assert_span_http_status_code(s, 200)
assert s.get_tag(http.URL) == URL_200 + "?" + query_string
assert s.error == 0
assert s.span_type == "http"
assert s.get_tag(http.QUERY_STRING) == query_string
def test_static_handler(self):
# it should create a trace with multiple spans
request = yield from self.client.request("GET", "/statics/empty.txt")
assert 200 == request.status
text = yield from request.text()
assert "Static file\n" == text
# the trace is created
traces = self.pop_traces()
assert 1 == len(traces)
assert 1 == len(traces[0])
span = traces[0][0]
# root span created in the middleware
assert "aiohttp.request" == span.name
assert "GET /statics" == span.resource
assert str(self.client.make_url("/statics/empty.txt")) == span.get_tag(
http.URL)
assert "GET" == span.get_tag("http.method")
assert_span_http_status_code(span, 200)
def test_2xx(self):
@self.app.route("/2xx")
def handled():
return bottle.HTTPResponse("", status=202)
self._trace_app(self.tracer)
# make a request
try:
self.app.get("/2xx")
except webtest.AppError:
pass
spans = self.pop_spans()
assert len(spans) == 1
s = spans[0]
assert s.resource == "GET /2xx"
assert_span_http_status_code(s, 202)
assert s.error == 0
def test_method_view_handler_error(self):
"""
When using a flask.views.View
When it raises an exception
We create spans as expected
"""
class TestView(MethodView):
def get(self, name):
raise Exception("an error")
self.app.add_url_rule("/hello/<name>", view_func=TestView.as_view("hello"))
res = self.client.get("/hello/flask")
self.assertEqual(res.status_code, 500)
spans = self.get_spans()
req_span = self.find_span_by_name(spans, "flask.request")
dispatch_span = self.find_span_by_name(spans, "flask.dispatch_request")
handler_span = self.find_span_by_name(spans, "tests.contrib.flask.test_views.hello")
# flask.request
self.assertEqual(req_span.error, 1)
self.assertEqual(req_span.get_tag("flask.endpoint"), "hello")
self.assertEqual(req_span.get_tag("flask.url_rule"), "/hello/<name>")
self.assertEqual(req_span.get_tag("flask.view_args.name"), "flask")
self.assertEqual(req_span.get_tag("http.method"), "GET")
assert_span_http_status_code(req_span, 500)
self.assertEqual(req_span.get_tag(http.URL), "http://localhost/hello/flask")
# flask.dispatch_request
self.assertEqual(dispatch_span.error, 1)
self.assertEqual(dispatch_span.get_tag("error.msg"), "an error")
self.assertTrue(dispatch_span.get_tag("error.stack").startswith("Traceback (most recent call last):"))
self.assertEqual(dispatch_span.get_tag("error.type"), base_exception_name)
# tests.contrib.flask.test_views.hello
# DEV: We do not add any additional metadata to view spans
self.assertEqual(handler_span.error, 1)
self.assertEqual(handler_span.get_tag("error.msg"), "an error")
self.assertTrue(handler_span.get_tag("error.stack").startswith("Traceback (most recent call last):"))
self.assertEqual(handler_span.get_tag("error.type"), base_exception_name)
def test_default_404_handler(self):
"""
When making a 404 request
And no user defined error handler is defined
We create the expected spans
"""
# Make our 404 request
res = self.client.get("/unknown")
self.assertEqual(res.status_code, 404)
spans = self.get_spans()
req_span = self.find_span_by_name(spans, "flask.request")
dispatch_span = self.find_span_by_name(spans, "flask.dispatch_request")
user_ex_span = self.find_span_by_name(spans,
"flask.handle_user_exception")
http_ex_span = self.find_span_by_name(spans,
"flask.handle_http_exception")
# flask.request span
self.assertEqual(req_span.error, 0)
assert_span_http_status_code(req_span, 404)
self.assertIsNone(req_span.get_tag("flask.endpoint"))
self.assertIsNone(req_span.get_tag("flask.url_rule"))
# flask.dispatch_request span
self.assertEqual(dispatch_span.error, 1)
error_msg = dispatch_span.get_tag("error.msg")
self.assertTrue(error_msg.startswith("404 Not Found"))
error_stack = dispatch_span.get_tag("error.stack")
self.assertTrue(
error_stack.startswith("Traceback (most recent call last):"))
error_type = dispatch_span.get_tag("error.type")
self.assertEqual(error_type, "werkzeug.exceptions.NotFound")
# flask.handle_user_exception span
self.assertEqual(user_ex_span.meta, dict())
self.assertEqual(user_ex_span.error, 0)
# flask.handle_http_exception span
self.assertEqual(http_ex_span.meta, dict())
self.assertEqual(http_ex_span.error, 0)
def test_bottle_global_tracer(self):
# without providing a Tracer instance, it should work
@self.app.route("/home/")
def home():
return "Hello world"
self._trace_app()
# make a request
resp = self.app.get("/home/")
assert resp.status_int == 200
# validate it's traced
spans = self.pop_spans()
assert len(spans) == 1
s = spans[0]
assert s.name == "bottle.request"
assert s.service == "bottle-app"
assert s.resource == "GET /home/"
assert_span_http_status_code(s, 200)
assert s.get_tag("http.method") == "GET"
def test_args_kwargs(self):
# ensure all valid combinations of args / kwargs work
url = URL_200
method = "GET"
inputs = [
([], {"method": method, "url": url}),
([method], {"url": url}),
([method, url], {}),
]
for args, kwargs in inputs:
# ensure a traced request works with these args
out = self.session.request(*args, **kwargs)
assert out.status_code == 200
# validation
spans = self.pop_spans()
assert len(spans) == 1
s = spans[0]
assert s.get_tag(http.METHOD) == "GET"
assert_span_http_status_code(s, 200)
def test_variable_resource(self):
self.getPage("/dispatch/abc123/")
time.sleep(0.1)
self.assertStatus("200 OK")
self.assertHeader("Content-Type", "text/html;charset=utf-8")
self.assertBody("dispatch with abc123")
# ensure trace worked
assert not self.tracer.current_span()
spans = self.pop_spans()
assert len(spans) == 1
s = spans[0]
assert s.service == "test.cherrypy.service"
# Once CherryPy returns sensible results for virtual path components, this
# can be: "GET /dispatch/{{test_value}}/"
assert s.resource == "GET /dispatch/abc123/"
assert s.error == 0
assert_span_http_status_code(s, 200)
assert s.get_tag(http.METHOD) == "GET"
def test_201(self):
out = self.make_test_call("/201",
method="post",
expected_status_code=201)
assert out.status_code == 201
assert out.content.decode("utf-8") == "Success"
traces = self.tracer.writer.pop_traces()
assert len(traces) == 1
assert len(traces[0]) == 1
span = traces[0][0]
assert_is_measured(span)
assert span.name == "falcon.request"
assert span.service == self._service
assert span.resource == "POST tests.contrib.falcon.app.resources.Resource201"
assert_span_http_status_code(span, 201)
assert span.get_tag(httpx.URL) == "http://falconframework.org/201"
assert span.parent_id is None
assert span.error == 0
