async def test_multiple_requests(app, tracer, test_spans):
with override_http_config("starlette", dict(trace_query_string=True)):
async with httpx.AsyncClient(app=app) as client:
responses = await asyncio.gather(
client.get("http://testserver/", params={"sleep": True}),
client.get("http://testserver/", params={"sleep": True}),
)
assert len(responses) == 2
assert [r.status_code for r in responses] == [200] * 2
assert [r.text for r in responses] == ["Success"] * 2
spans = test_spans.pop_traces()
assert len(spans) == 2
assert len(spans[0]) == 1
assert len(spans[1]) == 1
r1_span = spans[0][0]
assert r1_span.service == "starlette"
assert r1_span.name == "starlette.request"
assert r1_span.resource == "GET /"
assert r1_span.get_tag("http.method") == "GET"
assert r1_span.get_tag("http.url") == "http://testserver/"
assert r1_span.get_tag("http.query.string") == "sleep=true"
r2_span = spans[0][0]
assert r2_span.service == "starlette"
assert r2_span.name == "starlette.request"
assert r2_span.resource == "GET /"
assert r2_span.get_tag("http.method") == "GET"
assert r2_span.get_tag("http.url") == "http://testserver/"
assert r2_span.get_tag("http.query.string") == "sleep=true"
async def test_query_string(scope, tracer, test_spans):
with override_http_config("asgi", dict(trace_query_string=True)):
app = TraceMiddleware(basic_app, tracer=tracer)
scope["query_string"] = "foo=bar"
instance = ApplicationCommunicator(app, scope)
await instance.send_input({"type": "http.request", "body": b""})
response_start = await instance.receive_output(1)
assert response_start == {
"type": "http.response.start",
"status": 200,
"headers": [[b"Content-Type", b"text/plain"]],
}
response_body = await instance.receive_output(1)
assert response_body == {
"type": "http.response.body",
"body": b"*",
}
spans = test_spans.pop_traces()
assert len(spans) == 1
assert len(spans[0]) == 1
request_span = spans[0][0]
assert request_span.name == "asgi.request"
assert request_span.span_type == "web"
assert request_span.error == 0
assert request_span.get_tag("http.status_code") == "200"
_check_span_tags(scope, request_span)
def test_200_multi_query_string(client, tracer, test_spans):
with override_http_config("fastapi", dict(trace_query_string=True)):
r = client.get("/items/foo?name=Foo&q=query",
headers={"X-Token": "DataDog"})
assert r.status_code == 200
assert r.json() == {
"id": "foo",
"name": "Foo",
"description": "This item's description is foo."
}
spans = test_spans.pop_traces()
assert len(spans) == 1
assert len(spans[0]) == 2
request_span, serialize_span = spans[0]
assert request_span.service == "fastapi"
assert request_span.name == "fastapi.request"
assert request_span.resource == "GET /items/{item_id}"
assert request_span.error == 0
assert request_span.get_tag("http.method") == "GET"
assert request_span.get_tag("http.url") == "http://testserver/items/foo"
assert request_span.get_tag("http.status_code") == "200"
assert request_span.get_tag("http.query.string") == "name=Foo&q=query"
assert_serialize_span(serialize_span)
async def test_multiple_requests(application, tracer, test_spans):
with override_http_config("fastapi", dict(trace_query_string=True)):
async with httpx.AsyncClient(app=application) as client:
responses = await asyncio.gather(
client.get("http://testserver/", headers={"sleep": "True"}),
client.get("http://testserver/", headers={"sleep": "False"}),
)
assert len(responses) == 2
assert [r.status_code for r in responses] == [200] * 2
assert [r.json() for r in responses] == [{
"Homepage Read": "Sleep"
}, {
"Homepage Read": "Success"
}]
spans = test_spans.pop_traces()
assert len(spans) == 2
assert len(spans[0]) == 1
assert len(spans[1]) == 1
r1_span = spans[0][0]
assert r1_span.service == "fastapi"
assert r1_span.name == "fastapi.request"
assert r1_span.resource == "GET /"
assert r1_span.get_tag("http.method") == "GET"
assert r1_span.get_tag("http.url") == "http://testserver/"
r2_span = spans[1][0]
assert r2_span.service == "fastapi"
assert r2_span.name == "fastapi.request"
assert r2_span.resource == "GET /"
assert r2_span.get_tag("http.method") == "GET"
assert r2_span.get_tag("http.url") == "http://testserver/"
assert r1_span.trace_id != r2_span.trace_id
async def test_basic_app(tracer, client, integration_config,
integration_http_config, test_spans):
"""Test Sanic Patching"""
with override_http_config("sanic", integration_http_config):
with override_config("sanic", integration_config):
headers = [
(http_propagation.HTTP_HEADER_PARENT_ID, "1234"),
(http_propagation.HTTP_HEADER_TRACE_ID, "5678"),
]
response = await client.get("/hello",
params=[("foo", "bar")],
headers=headers)
assert _response_status(response) == 200
assert await _response_json(response) == {"hello": "world"}
spans = test_spans.pop_traces()
assert len(spans) == 1
assert len(spans[0]) == 2
request_span = spans[0][0]
assert request_span.name == "sanic.request"
assert request_span.error == 0
assert request_span.get_tag("http.method") == "GET"
assert re.search("/hello$", request_span.get_tag("http.url"))
assert request_span.get_tag("http.status_code") == "200"
assert request_span.resource == "GET /hello"
sleep_span = spans[0][1]
assert sleep_span.name == "tests.contrib.sanic.test_sanic.random_sleep"
assert sleep_span.parent_id == request_span.span_id
if integration_config.get("service"):
assert request_span.service == integration_config["service"]
else:
assert request_span.service == "sanic"
if integration_http_config.get("trace_query_string"):
assert request_span.get_tag("http.query.string") == "foo=bar"
else:
assert request_span.get_tag("http.query.string") is None
if integration_config.get("analytics_enabled"):
analytics_sample_rate = integration_config.get(
"analytics_sample_rate") or 1.0
assert request_span.get_metric(
ANALYTICS_SAMPLE_RATE_KEY) == analytics_sample_rate
else:
assert request_span.get_metric(ANALYTICS_SAMPLE_RATE_KEY) is None
if integration_config.get("distributed_tracing", True):
assert request_span.parent_id == 1234
assert request_span.trace_id == 5678
else:
assert request_span.parent_id is None
assert request_span.trace_id is not None and request_span.trace_id != 5678
async def test_trace_query_string(snapshot_context):
"""
When trace_query_string is enabled
We include the query string as a tag on the span
"""
url = get_url("/status/200?some=query&string=args")
with override_http_config("httpx", {"trace_query_string": True}):
with snapshot_context():
resp = httpx.get(url)
assert resp.status_code == 200
with snapshot_context():
async with httpx.AsyncClient() as client:
resp = await client.get(url)
assert resp.status_code == 200
def test_200_query_string(client, tracer, test_spans):
with override_http_config("starlette", dict(trace_query_string=True)):
r = client.get("?foo=bar")
assert r.status_code == 200
assert r.text == "Success"
request_span = next(test_spans.filter_spans(name="starlette.request"))
assert request_span.service == "starlette"
assert request_span.name == "starlette.request"
assert request_span.resource == "GET /"
assert request_span.error == 0
assert request_span.get_tag("http.method") == "GET"
assert request_span.get_tag("http.url") == "http://testserver/"
assert request_span.get_tag("http.status_code") == "200"
assert request_span.get_tag("http.query.string") == "foo=bar"
async def test_trace_query_string(snapshot_context):
"""
When trace_query_string is enabled
The query string is included as a tag on the span
"""
with override_http_config("aiohttp_client", {"trace_query_string": True}):
with snapshot_context():
async with aiohttp.ClientSession() as session:
async with session.get(
"%s/?k1=v1&k2=v2" % URL_200,
params={
"k3": "v3",
"k4": "v4",
},
) as resp:
assert resp.status == 404
def test_200_multi_query_string(client, tracer, test_spans):
with override_http_config("starlette", dict(trace_query_string=True)):
r = client.get("?foo=bar&x=y")
assert r.status_code == 200
assert r.text == "Success"
spans = test_spans.pop_traces()
assert len(spans) == 1
assert len(spans[0]) == 1
request_span = spans[0][0]
assert request_span.service == "starlette"
assert request_span.name == "starlette.request"
assert request_span.resource == "GET /"
assert request_span.error == 0
assert request_span.get_tag("http.method") == "GET"
assert request_span.get_tag("http.url") == "http://testserver/"
assert request_span.get_tag("http.status_code") == "200"
assert request_span.get_tag("http.query.string") == "foo=bar&x=y"
def test_query_string_tracing(tracer, test_spans):
with override_http_config("wsgi", dict(trace_query_string=True)):
app = TestApp(wsgi.DDWSGIMiddleware(application, tracer=tracer))
response = app.get("/?foo=bar&x=y")
assert response.status_int == 200
assert response.status == "200 OK"
spans = test_spans.pop_traces()
assert len(spans) == 1
assert len(spans[0]) == 4
request_span = spans[0][0]
assert request_span.service == "wsgi"
assert request_span.name == "wsgi.request"
assert request_span.resource == "GET /"
assert request_span.error == 0
assert request_span.get_tag("http.method") == "GET"
assert request_span.get_tag("http.status_code") == "200"
assert request_span.get_tag("http.query.string") == "foo=bar&x=y"
assert spans[0][1].name == "wsgi.application"
assert spans[0][2].name == "wsgi.start_response"
assert spans[0][3].name == "wsgi.response"
async def test_get_asgi_span(tracer, test_spans):
async def test_app(scope, receive, send):
message = await receive()
if message.get("type") == "http.request":
asgi_span = span_from_scope(scope)
assert asgi_span is not None
assert asgi_span.name == "asgi.request"
await send({
"type": "http.response.start",
"status": 200,
"headers": [[b"Content-Type", b"text/plain"]]
})
await send({"type": "http.response.body", "body": b""})
app = TraceMiddleware(test_app, tracer=tracer)
async with httpx.AsyncClient(app=app) as client:
response = await client.get("http://testserver/")
assert response.status_code == 200
with override_http_config("asgi", dict(trace_query_string=True)):
app = TraceMiddleware(test_app, tracer=tracer)
async with httpx.AsyncClient(app=app) as client:
response = await client.get("http://testserver/")
assert response.status_code == 200
async def test_app(scope, receive, send):
message = await receive()
if message.get("type") == "http.request":
root = tracer.current_root_span()
assert root.name == "root"
asgi_span = span_from_scope(scope)
assert asgi_span is not None
assert asgi_span.name == "asgi.request"
await send({
"type": "http.response.start",
"status": 200,
"headers": [[b"Content-Type", b"text/plain"]]
})
await send({"type": "http.response.body", "body": b""})
app = TraceMiddleware(test_app, tracer=tracer)
async with httpx.AsyncClient(app=app) as client:
with tracer.trace("root"):
response = await client.get("http://testserver/")
assert response.status_code == 200
async def test_app_no_middleware(scope, receive, send):
message = await receive()
if message.get("type") == "http.request":
asgi_span = span_from_scope(scope)
assert asgi_span is None
await send({
"type": "http.response.start",
"status": 200,
"headers": [[b"Content-Type", b"text/plain"]]
})
await send({"type": "http.response.body", "body": b""})
async with httpx.AsyncClient(app=test_app_no_middleware) as client:
response = await client.get("http://testserver/")
assert response.status_code == 200
