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