def test_not_distributed(self): # setup our test app @self.app.route('/hi/<name>') def hi(name): return 'hi %s' % name self._trace_app_not_distributed(self.tracer) # make a request headers = {'x-datadog-trace-id': '123', 'x-datadog-parent-id': '456'} resp = self.app.get('/hi/dougie', headers=headers) eq_(resp.status_int, 200) eq_(compat.to_unicode(resp.body), u'hi dougie') # validate it's traced spans = self.tracer.writer.pop() eq_(len(spans), 1) s = spans[0] eq_(s.name, 'bottle.request') eq_(s.service, 'bottle-app') eq_(s.resource, 'GET /hi/<name>') eq_(s.get_tag('http.status_code'), '200') eq_(s.get_tag('http.method'), 'GET') # check distributed headers assert_not_equal(123, s.trace_id) assert_not_equal(456, s.parent_id)
def test_to_unicode_bytearray_double_decode(self): # Calling `compat.to_unicode` with an already decoded `bytearray` # This represents the double-decode issue, which can cause a `UnicodeEncodeError` # `bytearray('\xc3\xbf').decode('utf-8').decode('utf-8')` res = to_unicode(bytearray('\xc3\xbf').decode('utf-8')) eq_(type(res), unicode) eq_(res, u'ÿ')
def test_analytics_global_off_integration_default(self): """ When making a request When an integration trace search is not set and sample rate is set and globally trace search is disabled We expect the root span to not include tag """ # setup our test app @self.app.route("/hi/<name>") def hi(name): return "hi %s" % name self._trace_app(self.tracer) with self.override_global_config(dict(analytics_enabled=False)): resp = self.app.get("/hi/dougie") assert resp.status_int == 200 assert compat.to_unicode(resp.body) == u"hi dougie" root = self.get_root_span() self.assertIsNone(root.get_metric(ANALYTICS_SAMPLE_RATE_KEY)) for span in self.spans: if span == root: continue self.assertIsNone(span.get_metric(ANALYTICS_SAMPLE_RATE_KEY))
def test_analytics_global_off_integration_on(self): """ When making a request When an integration trace search is enabled and sample rate is set and globally trace search is disabled We expect the root span to have the appropriate tag """ # setup our test app @self.app.route("/hi/<name>") def hi(name): return "hi %s" % name self._trace_app(self.tracer) with self.override_global_config(dict(analytics_enabled=False)): with self.override_config( "bottle", dict(analytics_enabled=True, analytics_sample_rate=0.5)): resp = self.app.get("/hi/dougie") assert resp.status_int == 200 assert compat.to_unicode(resp.body) == u"hi dougie" root = self.get_root_span() root.assert_matches( name="bottle.request", metrics={ ANALYTICS_SAMPLE_RATE_KEY: 0.5, }, ) for span in self.spans: if span == root: continue self.assertIsNone(span.get_metric(ANALYTICS_SAMPLE_RATE_KEY))
def test_analytics_global_on_integration_default(self): """ When making a request When an integration trace search is not event sample rate is not set and globally trace search is enabled We expect the root span to have the appropriate tag """ # setup our test app @self.app.route('/hi/<name>') def hi(name): return 'hi %s' % name self._trace_app(self.tracer) with self.override_global_config(dict(analytics_enabled=True)): resp = self.app.get('/hi/dougie') assert resp.status_int == 200 assert compat.to_unicode(resp.body) == u'hi dougie' root = self.get_root_span() root.assert_matches( name='bottle.request', metrics={ ANALYTICS_SAMPLE_RATE_KEY: 1.0, }, ) for span in self.spans: if span == root: continue self.assertIsNone(span.get_metric(ANALYTICS_SAMPLE_RATE_KEY))
def test_200(self, query_string=''): if query_string: fqs = '?' + query_string else: fqs = '' # setup our test app @self.app.route('/hi/<name>') def hi(name): return 'hi %s' % name self._trace_app(self.tracer) # make a request resp = self.app.get('/hi/dougie' + fqs) assert resp.status_int == 200 assert compat.to_unicode(resp.body) == u'hi dougie' # validate it's traced spans = self.tracer.writer.pop() assert len(spans) == 1 s = spans[0] assert s.name == 'bottle.request' assert s.service == 'bottle-app' assert s.span_type == 'web' assert s.resource == 'GET /hi/<name>' assert s.get_tag('http.status_code') == '200' assert s.get_tag('http.method') == 'GET' assert s.get_tag(http.URL) == 'http://localhost:80/hi/dougie' services = self.tracer.writer.pop_services() assert services == {}
def test_200(self): # setup our test app @self.app.route('/hi/<name>') def hi(name): return 'hi %s' % name self._trace_app(self.tracer) # make a request resp = self.app.get('/hi/dougie') eq_(resp.status_int, 200) eq_(compat.to_unicode(resp.body), u'hi dougie') # validate it's traced spans = self.tracer.writer.pop() eq_(len(spans), 1) s = spans[0] eq_(s.name, 'bottle.request') eq_(s.service, 'bottle-app') eq_(s.span_type, 'web') eq_(s.resource, 'GET /hi/<name>') eq_(s.get_tag('http.status_code'), '200') eq_(s.get_tag('http.method'), 'GET') services = self.tracer.writer.pop_services() eq_(len(services), 1) ok_(SERVICE in services) s = services[SERVICE] eq_(s['app_type'], 'web') eq_(s['app'], 'bottle')
def test_not_distributed(self): # setup our test app @self.app.route("/hi/<name>") def hi(name): return "hi %s" % name self._trace_app_not_distributed(self.tracer) # make a request headers = {"x-datadog-trace-id": "123", "x-datadog-parent-id": "456"} resp = self.app.get("/hi/dougie", headers=headers) assert resp.status_int == 200 assert compat.to_unicode(resp.body) == u"hi dougie" # validate it's traced spans = self.tracer.writer.pop() assert len(spans) == 1 s = spans[0] assert s.name == "bottle.request" assert s.service == "bottle-app" assert s.resource == "GET /hi/<name>" assert_span_http_status_code(s, 200) assert s.get_tag("http.method") == "GET" # check distributed headers assert 123 != s.trace_id assert 456 != s.parent_id
def test_200(self): # setup our test app @self.app.route('/hi/<name>') def hi(name): return 'hi %s' % name self._trace_app(self.tracer) # make a request resp = self.app.get('/hi/dougie') eq_(resp.status_int, 200) eq_(compat.to_unicode(resp.body), u'hi dougie') # validate it's traced spans = self.tracer.writer.pop() eq_(len(spans), 1) s = spans[0] eq_(s.name, 'bottle.request') eq_(s.service, 'bottle-app') eq_(s.resource, 'GET /hi/<name>') eq_(s.get_tag('http.status_code'), '200') eq_(s.get_tag('http.method'), 'GET') services = self.tracer.writer.pop_services() eq_(len(services), 1) ok_(SERVICE in services) s = services[SERVICE] eq_(s['app_type'], 'web') eq_(s['app'], 'bottle')
def test_to_unicode_bytearray_double_decode(self): # Calling `compat.to_unicode` with an already decoded `bytearray` # This represents the double-decode issue, which can cause a `UnicodeEncodeError` # `bytearray('\xc3\xbf').decode('utf-8').decode('utf-8')` res = to_unicode(bytearray(b'\xc3\xbf').decode('utf-8')) assert type(res) == unicode assert res == u'ÿ'
def test_to_unicode_unicode_double_decode(self): # Calling `compat.to_unicode` on a unicode decoded string # This represents the double-decode issue, which can cause a `UnicodeEncodeError` # `'\xc3\xbf'.decode('utf-8').decode('utf-8')` res = to_unicode(b'\xc3\xbf'.decode('utf-8')) assert type(res) == unicode assert res == u'ÿ'
def test_to_unicode_unicode_double_decode(self): # Calling `compat.to_unicode` on a unicode decoded string # This represents the double-decode issue, which can cause a `UnicodeEncodeError` # `'\xc3\xbf'.decode('utf-8').decode('utf-8')` res = to_unicode('\xc3\xbf'.decode('utf-8')) eq_(type(res), unicode) eq_(res, u'ÿ')
def test_not_distributed(self): # setup our test app @self.app.route('/hi/<name>') def hi(name): return 'hi %s' % name self._trace_app_not_distributed(self.tracer) # make a request headers = {'x-datadog-trace-id': '123', 'x-datadog-parent-id': '456'} resp = self.app.get('/hi/dougie', headers=headers) assert resp.status_int == 200 assert compat.to_unicode(resp.body) == u'hi dougie' # validate it's traced spans = self.tracer.writer.pop() assert len(spans) == 1 s = spans[0] assert s.name == 'bottle.request' assert s.service == 'bottle-app' assert s.resource == 'GET /hi/<name>' assert s.get_metric('http.status_code') == 200 assert s.get_tag('http.method') == 'GET' # check distributed headers assert 123 != s.trace_id assert 456 != s.parent_id
def test_redis_legacy(): # ensure the old interface isn't broken, but doesn't trace tracer = get_dummy_tracer() TracedRedisCache = get_traced_redis(tracer, "foo") r = TracedRedisCache(port=REDIS_CONFIG['port']) r.set("a", "b") got = r.get("a") eq_(compat.to_unicode(got), "b") assert not tracer.writer.pop()
def test_redis_legacy(): # ensure the old interface isn't broken, but doesn't trace tracer = get_dummy_tracer() TracedRedisCache = get_traced_redis(tracer, 'foo') r = TracedRedisCache(port=REDIS_CONFIG['port']) r.set('a', 'b') got = r.get('a') assert compat.to_unicode(got) == 'b' assert not tracer.writer.pop()
def test_redis_legacy(): # ensure the old interface isn't broken, but doesn't trace tracer = get_dummy_tracer() TracedRedisCache = get_traced_redis(tracer, "foo") r = TracedRedisCache(port=REDIS_CONFIG['port']) r.set("a", "b") got = r.get("a") eq_(compat.to_unicode(got), "b") assert not tracer.writer.pop()
def func(response): try: # pull out response code from gRPC response to use both for `grpc.status.code` # tag and the error type tag if the response is an exception response_code = response.code() # cast code to unicode for tags status_code = to_unicode(response_code) span._set_str_tag(constants.GRPC_STATUS_CODE_KEY, status_code) if response_code != grpc.StatusCode.OK: _handle_error(span, response, status_code) finally: span.finish()
def test_render(self): # render t = Template("Hello ${name}!") self.assertEqual(t.render(name="mako"), "Hello mako!") spans = self.pop_spans() self.assertEqual(len(spans), 1) assert_is_measured(spans[0]) self.assertEqual(spans[0].service, "mako") self.assertEqual(spans[0].span_type, "template") self.assertEqual(spans[0].get_tag("mako.template_name"), DEFAULT_TEMPLATE_NAME) self.assertEqual(spans[0].name, "mako.template.render") self.assertEqual(spans[0].resource, DEFAULT_TEMPLATE_NAME) # render_unicode t = Template("Hello ${name}!") self.assertEqual(t.render_unicode(name="mako"), to_unicode("Hello mako!")) spans = self.pop_spans() self.assertEqual(len(spans), 1) assert_is_measured(spans[0]) self.assertEqual(spans[0].service, "mako") self.assertEqual(spans[0].span_type, "template") self.assertEqual(spans[0].get_tag("mako.template_name"), DEFAULT_TEMPLATE_NAME) self.assertEqual(spans[0].name, "mako.template.render_unicode") self.assertEqual(spans[0].resource, DEFAULT_TEMPLATE_NAME) # render_context t = Template("Hello ${name}!") buf = StringIO() c = Context(buf, name="mako") t.render_context(c) self.assertEqual(buf.getvalue(), "Hello mako!") spans = self.pop_spans() self.assertEqual(len(spans), 1) assert_is_measured(spans[0]) self.assertEqual(spans[0].service, "mako") self.assertEqual(spans[0].span_type, "template") self.assertEqual(spans[0].get_tag("mako.template_name"), DEFAULT_TEMPLATE_NAME) self.assertEqual(spans[0].name, "mako.template.render_context") self.assertEqual(spans[0].resource, DEFAULT_TEMPLATE_NAME)
def test_render(self): # render t = Template('Hello ${name}!') self.assertEqual(t.render(name='mako'), 'Hello mako!') spans = self.tracer.writer.pop() self.assertEqual(len(spans), 1) assert_is_measured(spans[0]) self.assertEqual(spans[0].service, 'mako') self.assertEqual(spans[0].span_type, 'template') self.assertEqual(spans[0].get_tag('mako.template_name'), '<memory>') self.assertEqual(spans[0].name, 'mako.template.render') self.assertEqual(spans[0].resource, '<memory>') # render_unicode t = Template('Hello ${name}!') self.assertEqual(t.render_unicode(name='mako'), to_unicode('Hello mako!')) spans = self.tracer.writer.pop() self.assertEqual(len(spans), 1) assert_is_measured(spans[0]) self.assertEqual(spans[0].service, 'mako') self.assertEqual(spans[0].span_type, 'template') self.assertEqual(spans[0].get_tag('mako.template_name'), '<memory>') self.assertEqual(spans[0].name, 'mako.template.render_unicode') self.assertEqual(spans[0].resource, '<memory>') # render_context t = Template('Hello ${name}!') buf = StringIO() c = Context(buf, name='mako') t.render_context(c) self.assertEqual(buf.getvalue(), 'Hello mako!') spans = self.tracer.writer.pop() self.assertEqual(len(spans), 1) assert_is_measured(spans[0]) self.assertEqual(spans[0].service, 'mako') self.assertEqual(spans[0].span_type, 'template') self.assertEqual(spans[0].get_tag('mako.template_name'), '<memory>') self.assertEqual(spans[0].name, 'mako.template.render_context') self.assertEqual(spans[0].resource, '<memory>')
def test_200(self): # setup our test app @self.app.route("/hi/<name>") def hi(name): return "hi %s" % name self._trace_app(self.tracer) # make a request resp = self.app.get("/hi/dougie") assert resp.status_int == 200 assert compat.to_unicode(resp.body) == u"hi dougie" # 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 /hi/<name>" assert_span_http_status_code(s, 200) assert s.get_tag("http.method") == "GET"
def test_json(): app, tracer = _get_test_app(service='foobar') res = app.get('/json', status=200) parsed = json.loads(compat.to_unicode(res.body)) eq_(parsed, {'a':1}) writer = tracer.writer spans = writer.pop() eq_(len(spans), 2) spans_by_name = {s.name:s for s in spans} s = spans_by_name['pyramid.request'] eq_(s.service, 'foobar') eq_(s.resource, 'json') eq_(s.error, 0) eq_(s.span_type, 'http') eq_(s.meta.get('http.status_code'), '200') eq_(s.meta.get('http.url'), '/json') s = spans_by_name['pyramid.render'] eq_(s.service, 'foobar') eq_(s.error, 0) eq_(s.span_type, 'template')
def test_200_ot(self): ot_tracer = init_tracer('my_svc', self.tracer) # setup our test app @self.app.route('/hi/<name>') def hi(name): return 'hi %s' % name self._trace_app(self.tracer) # make a request with ot_tracer.start_active_span('ot_span'): resp = self.app.get('/hi/dougie') eq_(resp.status_int, 200) eq_(compat.to_unicode(resp.body), u'hi dougie') # validate it's traced spans = self.tracer.writer.pop() eq_(len(spans), 2) ot_span, dd_span = spans # confirm the parenting eq_(ot_span.parent_id, None) eq_(dd_span.parent_id, ot_span.span_id) eq_(ot_span.resource, 'ot_span') eq_(dd_span.name, 'bottle.request') eq_(dd_span.service, 'bottle-app') eq_(dd_span.resource, 'GET /hi/<name>') eq_(dd_span.get_tag('http.status_code'), '200') eq_(dd_span.get_tag('http.method'), 'GET') services = self.tracer.writer.pop_services() eq_(len(services), 1) ok_(SERVICE in services) s = services[SERVICE] eq_(s['app_type'], 'web') eq_(s['app'], 'bottle')
def test_200(self): # setup our test app @self.app.route('/hi/<name>') def hi(name): return 'hi %s' % name self._trace_app(self.tracer) # make a request resp = self.app.get('/hi/dougie') assert resp.status_int == 200 assert compat.to_unicode(resp.body) == u'hi dougie' # validate it's traced spans = self.tracer.writer.pop() assert len(spans) == 1 s = spans[0] assert s.name == 'bottle.request' assert s.service == 'bottle-app' assert s.resource == 'GET /hi/<name>' assert s.get_tag('http.status_code') == '200' assert s.get_tag('http.method') == 'GET' services = self.tracer.writer.pop_services() assert services == {}
def test_json(self): res = self.app.get("/json", status=200) parsed = json.loads(compat.to_unicode(res.body)) assert parsed == {"a": 1} spans = self.pop_spans() assert len(spans) == 2 spans_by_name = {s.name: s for s in spans} s = spans_by_name["pyramid.request"] assert_is_measured(s) assert s.service == "foobar" assert s.resource == "GET json" assert s.error == 0 assert s.span_type == "web" assert s.meta.get("http.method") == "GET" assert_span_http_status_code(s, 200) assert s.meta.get(http.URL) == "http://localhost/json" assert s.meta.get("pyramid.route.name") == "json" s = spans_by_name["pyramid.render"] assert s.service == "foobar" assert s.error == 0 assert s.span_type == "template"
def test_200(): # setup our test app app = bottle.Bottle() @app.route('/hi/<name>') def hi(name): return 'hi %s' % name tracer, app = _trace_app(app) # make a request resp = app.get("/hi/dougie") eq_(resp.status_int, 200) eq_(compat.to_unicode(resp.body), u'hi dougie') # validate it's traced spans = tracer.writer.pop() eq_(len(spans), 1) s = spans[0] eq_(s.name, "bottle.request") eq_(s.service, "foobar") eq_(s.resource, "GET /hi/<name>") eq_(s.get_tag('http.status_code'), '200') eq_(s.get_tag('http.method'), 'GET')
def test_json(self): res = self.app.get('/json', status=200) parsed = json.loads(compat.to_unicode(res.body)) assert parsed == {'a': 1} writer = self.tracer.writer spans = writer.pop() assert len(spans) == 2 spans_by_name = {s.name: s for s in spans} s = spans_by_name['pyramid.request'] assert s.service == 'foobar' assert s.resource == 'GET json' assert s.error == 0 assert s.span_type == 'web' assert s.meta.get('http.method') == 'GET' assert_span_http_status_code(s, 200) assert s.meta.get(http.URL) == 'http://localhost/json' assert s.meta.get('pyramid.route.name') == 'json' s = spans_by_name['pyramid.render'] assert s.service == 'foobar' assert s.error == 0 assert s.span_type == 'template'
def test_json(self): res = self.app.get('/json', status=200) parsed = json.loads(compat.to_unicode(res.body)) eq_(parsed, {'a': 1}) writer = self.tracer.writer spans = writer.pop() eq_(len(spans), 2) spans_by_name = {s.name: s for s in spans} s = spans_by_name['pyramid.request'] eq_(s.service, 'foobar') eq_(s.resource, 'GET json') eq_(s.error, 0) eq_(s.span_type, 'http') eq_(s.meta.get('http.method'), 'GET') eq_(s.meta.get('http.status_code'), '200') eq_(s.meta.get('http.url'), '/json') eq_(s.meta.get('pyramid.route.name'), 'json') s = spans_by_name['pyramid.render'] eq_(s.service, 'foobar') eq_(s.error, 0) eq_(s.span_type, 'template')
def test_200_ot(self): ot_tracer = init_tracer('my_svc', self.tracer) # setup our test app @self.app.route('/hi/<name>') def hi(name): return 'hi %s' % name self._trace_app(self.tracer) # make a request with ot_tracer.start_active_span('ot_span'): resp = self.app.get('/hi/dougie') assert resp.status_int == 200 assert compat.to_unicode(resp.body) == u'hi dougie' # validate it's traced spans = self.tracer.writer.pop() assert len(spans) == 2 ot_span, dd_span = spans # confirm the parenting assert ot_span.parent_id is None assert dd_span.parent_id == ot_span.span_id assert ot_span.resource == 'ot_span' assert_is_measured(dd_span) assert dd_span.name == 'bottle.request' assert dd_span.service == 'bottle-app' assert dd_span.resource == 'GET /hi/<name>' assert_span_http_status_code(dd_span, 200) assert dd_span.get_tag('http.method') == 'GET' assert dd_span.get_tag(http.URL) == 'http://localhost:80/hi/dougie' services = self.tracer.writer.pop_services() assert services == {}
def test_200_ot(self): ot_tracer = init_tracer("my_svc", self.tracer) # setup our test app @self.app.route("/hi/<name>") def hi(name): return "hi %s" % name self._trace_app(self.tracer) # make a request with ot_tracer.start_active_span("ot_span"): resp = self.app.get("/hi/dougie") assert resp.status_int == 200 assert compat.to_unicode(resp.body) == u"hi dougie" # validate it's traced spans = self.tracer.writer.pop() assert len(spans) == 2 ot_span, dd_span = spans # confirm the parenting assert ot_span.parent_id is None assert dd_span.parent_id == ot_span.span_id assert ot_span.resource == "ot_span" assert_is_measured(dd_span) assert dd_span.name == "bottle.request" assert dd_span.service == "bottle-app" assert dd_span.resource == "GET /hi/<name>" assert_span_http_status_code(dd_span, 200) assert dd_span.get_tag("http.method") == "GET" assert dd_span.get_tag(http.URL) == "http://localhost:80/hi/dougie" services = self.tracer.writer.pop_services() assert services == {}
def test_200(self, query_string=""): if query_string: fqs = "?" + query_string else: fqs = "" # setup our test app @self.app.route("/hi/<name>") def hi(name): return "hi %s" % name self._trace_app(self.tracer) # make a request resp = self.app.get("/hi/dougie" + fqs) assert resp.status_int == 200 assert compat.to_unicode(resp.body) == u"hi dougie" # validate it's traced spans = self.tracer.writer.pop() assert len(spans) == 1 s = spans[0] assert_is_measured(s) assert s.name == "bottle.request" assert s.service == "bottle-app" assert s.span_type == "web" assert s.resource == "GET /hi/<name>" assert_span_http_status_code(s, 200) assert s.get_tag("http.method") == "GET" assert s.get_tag(http.URL) == "http://localhost:80/hi/dougie" if ddtrace.config.bottle.trace_query_string: assert s.get_tag(http.QUERY_STRING) == query_string else: assert http.QUERY_STRING not in s.meta services = self.tracer.writer.pop_services() assert services == {}
def test_to_unicode_bytearray(self): # Calling `compat.to_unicode` with a `bytearray` containing unicode res = to_unicode(bytearray('\xc3\xbf')) eq_(type(res), unicode) eq_(res, u'ÿ')
def wrapper(wrapped, instance, args, kwargs): if len(args) > 1: self = args[0] clsname = self.__class__.__name__ else: clsname = "" if include_tracer: tracer = Tracer() else: tracer = ddtrace.tracer module = inspect.getmodule(wrapped) # Use the fully qualified function name as a unique test token to # identify the snapshot. token = "{}{}{}.{}".format(module.__name__, "." if clsname else "", clsname, wrapped.__name__) # Use variant that applies to update test token. One must apply. If none # apply, the test should have been marked as skipped. if variants: applicable_variant_ids = [k for (k, v) in variants.items() if v] assert len(applicable_variant_ids) == 1 variant_id = applicable_variant_ids[0] token = "{}_{}".format(token, variant_id) if variant_id else token parsed = parse.urlparse(tracer.writer.agent_url) conn = httplib.HTTPConnection(parsed.hostname, parsed.port) try: # clear queue in case traces have been generated before test case is # itself run try: tracer.writer.flush_queue() except Exception as e: pytest.fail("Could not flush the queue before test case: %s" % str(e), pytrace=True) if async_mode: # Patch the tracer writer to include the test token header for all requests. tracer.writer._headers["X-Datadog-Test-Token"] = token else: # Signal the start of this test case to the test agent. try: conn.request("GET", "/test/start?token=%s" % token) except Exception as e: pytest.fail("Could not connect to test agent: %s" % str(e), pytrace=False) else: r = conn.getresponse() if r.status != 200: # The test agent returns nice error messages we can forward to the user. raise SnapshotFailed(r.read()) # Run the test. try: if include_tracer: kwargs["tracer"] = tracer ret = wrapped(*args, **kwargs) # Force a flush so all traces are submitted. tracer.writer.flush_queue() finally: if async_mode: del tracer.writer._headers["X-Datadog-Test-Token"] # Query for the results of the test. conn = httplib.HTTPConnection(parsed.hostname, parsed.port) conn.request( "GET", "/test/snapshot?ignores=%s&token=%s" % (",".join(ignores), token)) r = conn.getresponse() if r.status != 200: raise SnapshotFailed(r.read()) return ret except SnapshotFailed as e: # Fail the test if a failure has occurred and print out the # message we got from the test agent. pytest.fail(to_unicode(e.args[0]), pytrace=False) except Exception as e: # Even though it's unlikely any traces have been sent, make the # final request to the test agent so that the test case is finished. conn = httplib.HTTPConnection(parsed.hostname, parsed.port) conn.request( "GET", "/test/snapshot?ignores=%s&token=%s" % (",".join(ignores), token)) conn.getresponse() pytest.fail("Unexpected test failure during snapshot test: %s" % str(e), pytrace=True) finally: conn.close()
def test_to_unicode_unicode_encoded(self): # Calling `compat.to_unicode` on a unicode encoded string res = to_unicode('\xff') eq_(type(res), str) eq_(res, 'ÿ')
def traced_wsgi_app(pin, wrapped, instance, args, kwargs): """ Wrapper for flask.app.Flask.wsgi_app This wrapper is the starting point for all requests. """ # DEV: This is safe before this is the args for a WSGI handler # https://www.python.org/dev/peps/pep-3333/ environ, start_response = args # Create a werkzeug request from the `environ` to make interacting with it easier # DEV: This executes before a request context is created request = werkzeug.Request(environ) # Configure distributed tracing if config.flask.get('distributed_tracing_enabled', False): propagator = HTTPPropagator() context = propagator.extract(request.headers) # Only need to activate the new context if something was propagated if context.trace_id: pin.tracer.context_provider.activate(context) # Default resource is method and path: # GET / # POST /save # We will override this below in `traced_dispatch_request` when we have a `RequestContext` and possibly a url rule resource = u'{} {}'.format(request.method, request.path) with pin.tracer.trace('flask.request', service=pin.service, resource=resource, span_type=http.TYPE) as s: # set analytics sample rate with global config enabled sample_rate = config.flask.get_analytics_sample_rate( use_global_config=True) if sample_rate is not None: s.set_tag(ANALYTICS_SAMPLE_RATE_KEY, sample_rate) s.set_tag(FLASK_VERSION, flask_version_str) # Wrap the `start_response` handler to extract response code # DEV: We tried using `Flask.finalize_request`, which seemed to work, but gave us hell during tests # DEV: The downside to using `start_response` is we do not have a `Flask.Response` object here, # only `status_code`, and `headers` to work with # On the bright side, this works in all versions of Flask (or any WSGI app actually) def _wrap_start_response(func): def traced_start_response(status_code, headers): code, _, _ = status_code.partition(' ') try: code = int(code) except ValueError: pass # Override root span resource name to be `<method> 404` for 404 requests # DEV: We do this because we want to make it easier to see all unknown requests together # Also, we do this to reduce the cardinality on unknown urls # DEV: If we have an endpoint or url rule tag, then we don't need to do this, # we still want `GET /product/<int:product_id>` grouped together, # even if it is a 404 if not s.get_tag(FLASK_ENDPOINT) and not s.get_tag( FLASK_URL_RULE): s.resource = u'{} {}'.format(request.method, code) s.set_tag(http.STATUS_CODE, code) if 500 <= code < 600: s.error = 1 elif code in config.flask.get('extra_error_codes', set()): s.error = 1 return func(status_code, headers) return traced_start_response start_response = _wrap_start_response(start_response) # DEV: We set response status code in `_wrap_start_response` # DEV: Use `request.base_url` and not `request.url` to keep from leaking any query string parameters s.set_tag(http.URL, request.base_url) s.set_tag(http.METHOD, request.method) if config.flask.trace_query_string: s.set_tag(http.QUERY_STRING, compat.to_unicode(request.query_string)) return wrapped(environ, start_response)
def test_to_unicode_unicode_string(self): # Calling `compat.to_unicode` on a unicode string res = to_unicode('ÿ') eq_(type(res), str) eq_(res, 'ÿ')
def test_to_unicode_non_string(self): # Calling `compat.to_unicode` on non-string types assert to_unicode(1) == u"1" assert to_unicode(True) == u"True" assert to_unicode(None) == u"None" assert to_unicode(dict(key="value")) == u"{'key': 'value'}"
def test_to_unicode_bytearray(self): # Calling `compat.to_unicode` with a `bytearray` containing unicode res = to_unicode(bytearray(b"\xc3\xbf")) assert type(res) == unicode assert res == u"ÿ"
def test_to_unicode_unicode_string(self): # Calling `compat.to_unicode` on a unicode string res = to_unicode(u"ÿ") assert type(res) == unicode assert res == u"ÿ"
def test_to_unicode_unicode_encoded(self): # Calling `compat.to_unicode` on a unicode encoded string res = to_unicode(b"\xc3\xbf") assert type(res) == unicode assert res == u"ÿ"
def test_to_unicode_unicode_encoded(self): # Calling `compat.to_unicode` on a unicode encoded string res = to_unicode('\xc3\xbf') eq_(type(res), unicode) eq_(res, u'ÿ')
def test_to_unicode_non_string(self): # Calling `compat.to_unicode` on non-string types eq_(to_unicode(1), '1') eq_(to_unicode(True), 'True') eq_(to_unicode(None), 'None') eq_(to_unicode(dict(key='value')), '{\'key\': \'value\'}')
def test_to_unicode_bytearray(self): # Calling `compat.to_unicode` with a `bytearray` containing unicode """ res = to_unicode(bytearray('\xff', 'utf-8')) eq_(type(res), str) eq_(res, 'ÿ')
def test_to_unicode_string(self): # Calling `compat.to_unicode` on a non-unicode string res = to_unicode('test') eq_(type(res), unicode) eq_(res, 'test')