class TestAPITransport(TestCase):
"""
Ensures that traces are properly sent to a local agent. These are part
of integration tests so real calls are triggered and you have to execute
a real trace-agent to let them pass.
"""
@mock.patch('ddtrace.internal.runtime.container.get_container_info')
def setUp(self, get_container_info):
"""
Create a tracer without workers, while spying the ``send()`` method
"""
# Mock the container id we use for making requests
get_container_info.return_value = CGroupInfo(
container_id='test-container-id')
# create a new API object to test the transport using synchronous calls
self.tracer = get_dummy_tracer()
self.api_json = API('localhost', 8126, encoder=JSONEncoder())
self.api_msgpack = API('localhost', 8126, encoder=MsgpackEncoder())
@mock.patch('ddtrace.api.httplib.HTTPConnection')
def test_send_presampler_headers(self, mocked_http):
# register a single trace with a span and send them to the trace agent
self.tracer.trace('client.testing').finish()
trace = self.tracer.writer.pop()
traces = [trace]
# make a call and retrieve the `conn` Mock object
self.api_msgpack.send_traces(traces)
request_call = mocked_http.return_value.request
assert request_call.call_count == 1
# retrieve the headers from the mocked request call
expected_headers = {
'Datadog-Container-Id': 'test-container-id', # mocked in setUp()
'Datadog-Meta-Lang': 'python',
'Datadog-Meta-Lang-Interpreter': PYTHON_INTERPRETER,
'Datadog-Meta-Lang-Version': PYTHON_VERSION,
'Datadog-Meta-Tracer-Version': ddtrace.__version__,
'X-Datadog-Trace-Count': '1',
'Content-Type': 'application/msgpack',
}
params, _ = request_call.call_args_list[0]
headers = params[3]
assert len(expected_headers) == len(headers)
for k, v in expected_headers.items():
assert v == headers[k]
@mock.patch('ddtrace.api.httplib.HTTPConnection')
def test_send_presampler_headers_not_in_services(self, mocked_http):
# register some services and send them to the trace agent
services = [{
'client.service': {
'app': 'django',
'app_type': 'web',
},
}]
# make a call and retrieve the `conn` Mock object
self.api_msgpack.send_services(services)
request_call = mocked_http.return_value.request
assert request_call.call_count == 0
def _send_traces_and_check(self, traces, nresponses=1):
# test JSON encoder
responses = self.api_json.send_traces(traces)
assert len(responses) == nresponses
for response in responses:
assert response.status == 200
# test Msgpack encoder
responses = self.api_msgpack.send_traces(traces)
assert len(responses) == nresponses
for response in responses:
assert response.status == 200
def test_send_single_trace(self):
# register a single trace with a span and send them to the trace agent
self.tracer.trace('client.testing').finish()
trace = self.tracer.writer.pop()
traces = [trace]
self._send_traces_and_check(traces)
def test_send_many_traces(self):
# register a single trace with a span and send them to the trace agent
self.tracer.trace('client.testing').finish()
trace = self.tracer.writer.pop()
# 30k is a right number to have both json and msgpack send 2 payload :)
traces = [trace] * 30000
self._send_traces_and_check(traces, 2)
def test_send_single_with_wrong_errors(self):
# if the error field is set to True, it must be cast as int so
# that the agent decoder handles that properly without providing
# a decoding error
span = self.tracer.trace('client.testing')
span.error = True
span.finish()
trace = self.tracer.writer.pop()
traces = [trace]
self._send_traces_and_check(traces)
def test_send_multiple_traces(self):
# register some traces and send them to the trace agent
self.tracer.trace('client.testing').finish()
trace_1 = self.tracer.writer.pop()
self.tracer.trace('client.testing').finish()
trace_2 = self.tracer.writer.pop()
traces = [trace_1, trace_2]
self._send_traces_and_check(traces)
def test_send_single_trace_multiple_spans(self):
# register some traces and send them to the trace agent
with self.tracer.trace('client.testing'):
self.tracer.trace('client.testing').finish()
trace = self.tracer.writer.pop()
traces = [trace]
self._send_traces_and_check(traces)
def test_send_multiple_traces_multiple_spans(self):
# register some traces and send them to the trace agent
with self.tracer.trace('client.testing'):
self.tracer.trace('client.testing').finish()
trace_1 = self.tracer.writer.pop()
with self.tracer.trace('client.testing'):
self.tracer.trace('client.testing').finish()
trace_2 = self.tracer.writer.pop()
traces = [trace_1, trace_2]
self._send_traces_and_check(traces)
def test_send_single_service(self):
# register some services and send them to the trace agent
services = [{
'client.service': {
'app': 'django',
'app_type': 'web',
},
}]
# test JSON encoder
response = self.api_json.send_services(services)
assert response is None
# test Msgpack encoder
response = self.api_msgpack.send_services(services)
assert response is None
def test_send_service_called_multiple_times(self):
# register some services and send them to the trace agent
services = [{
'backend': {
'app': 'django',
'app_type': 'web',
},
'database': {
'app': 'postgres',
'app_type': 'db',
},
}]
# test JSON encoder
response = self.api_json.send_services(services)
assert response is None
# test Msgpack encoder
response = self.api_msgpack.send_services(services)
assert response is None
class TestAPITransport(TestCase):
"""
Ensures that traces are properly sent to a local agent. These are part
of integration tests so real calls are triggered and you have to execute
a real trace-agent to let them pass.
"""
def setUp(self):
"""
Create a tracer without workers, while spying the ``send()`` method
"""
# create a new API object to test the transport using synchronous calls
self.tracer = get_dummy_tracer()
self.api_json = API('localhost', 8126, encoder=JSONEncoder())
self.api_msgpack = API('localhost', 8126, encoder=MsgpackEncoder())
@mock.patch('ddtrace.api.httplib.HTTPConnection')
def test_send_presampler_headers(self, mocked_http):
# register a single trace with a span and send them to the trace agent
self.tracer.trace('client.testing').finish()
trace = self.tracer.writer.pop()
traces = [trace]
# make a call and retrieve the `conn` Mock object
response = self.api_msgpack.send_traces(traces)
request_call = mocked_http.return_value.request
eq_(request_call.call_count, 1)
# retrieve the headers from the mocked request call
expected_headers = {
'Datadog-Meta-Lang': 'python',
'Datadog-Meta-Lang-Interpreter': PYTHON_INTERPRETER,
'Datadog-Meta-Lang-Version': PYTHON_VERSION,
'Datadog-Meta-Tracer-Version': ddtrace.__version__,
'X-Datadog-Trace-Count': '1',
'Content-Type': 'application/msgpack'
}
params, _ = request_call.call_args_list[0]
headers = params[3]
eq_(len(expected_headers), len(headers))
for k, v in expected_headers.items():
eq_(v, headers[k])
@mock.patch('ddtrace.api.httplib.HTTPConnection')
def test_send_presampler_headers_not_in_services(self, mocked_http):
# register some services and send them to the trace agent
services = [{
'client.service': {
'app': 'django',
'app_type': 'web',
},
}]
# make a call and retrieve the `conn` Mock object
response = self.api_msgpack.send_services(services)
request_call = mocked_http.return_value.request
eq_(request_call.call_count, 1)
# retrieve the headers from the mocked request call
expected_headers = {
'Datadog-Meta-Lang': 'python',
'Datadog-Meta-Lang-Interpreter': PYTHON_INTERPRETER,
'Datadog-Meta-Lang-Version': PYTHON_VERSION,
'Datadog-Meta-Tracer-Version': ddtrace.__version__,
'Content-Type': 'application/msgpack'
}
params, _ = request_call.call_args_list[0]
headers = params[3]
eq_(len(expected_headers), len(headers))
for k, v in expected_headers.items():
eq_(v, headers[k])
# retrieve the headers from the mocked request call
params, _ = request_call.call_args_list[0]
headers = params[3]
ok_('X-Datadog-Trace-Count' not in headers.keys())
def test_send_single_trace(self):
# register a single trace with a span and send them to the trace agent
self.tracer.trace('client.testing').finish()
trace = self.tracer.writer.pop()
traces = [trace]
# test JSON encoder
response = self.api_json.send_traces(traces)
ok_(response)
eq_(response.status, 200)
# test Msgpack encoder
response = self.api_msgpack.send_traces(traces)
ok_(response)
eq_(response.status, 200)
def test_send_single_with_wrong_errors(self):
# if the error field is set to True, it must be cast as int so
# that the agent decoder handles that properly without providing
# a decoding error
span = self.tracer.trace('client.testing')
span.error = True
span.finish()
trace = self.tracer.writer.pop()
traces = [trace]
# test JSON encoder
response = self.api_json.send_traces(traces)
ok_(response)
eq_(response.status, 200)
# test Msgpack encoder
response = self.api_msgpack.send_traces(traces)
ok_(response)
eq_(response.status, 200)
def test_send_multiple_traces(self):
# register some traces and send them to the trace agent
self.tracer.trace('client.testing').finish()
trace_1 = self.tracer.writer.pop()
self.tracer.trace('client.testing').finish()
trace_2 = self.tracer.writer.pop()
traces = [trace_1, trace_2]
# test JSON encoder
response = self.api_json.send_traces(traces)
ok_(response)
eq_(response.status, 200)
# test Msgpack encoder
response = self.api_msgpack.send_traces(traces)
ok_(response)
eq_(response.status, 200)
def test_send_single_trace_multiple_spans(self):
# register some traces and send them to the trace agent
with self.tracer.trace('client.testing'):
self.tracer.trace('client.testing').finish()
trace = self.tracer.writer.pop()
traces = [trace]
# test JSON encoder
response = self.api_json.send_traces(traces)
ok_(response)
eq_(response.status, 200)
# test Msgpack encoder
response = self.api_msgpack.send_traces(traces)
ok_(response)
eq_(response.status, 200)
def test_send_multiple_traces_multiple_spans(self):
# register some traces and send them to the trace agent
with self.tracer.trace('client.testing'):
self.tracer.trace('client.testing').finish()
trace_1 = self.tracer.writer.pop()
with self.tracer.trace('client.testing'):
self.tracer.trace('client.testing').finish()
trace_2 = self.tracer.writer.pop()
traces = [trace_1, trace_2]
# test JSON encoder
response = self.api_json.send_traces(traces)
ok_(response)
eq_(response.status, 200)
# test Msgpack encoder
response = self.api_msgpack.send_traces(traces)
ok_(response)
eq_(response.status, 200)
def test_send_single_service(self):
# register some services and send them to the trace agent
services = [{
'client.service': {
'app': 'django',
'app_type': 'web',
},
}]
# test JSON encoder
response = self.api_json.send_services(services)
ok_(response)
eq_(response.status, 200)
# test Msgpack encoder
response = self.api_msgpack.send_services(services)
ok_(response)
eq_(response.status, 200)
def test_send_service_called_multiple_times(self):
# register some services and send them to the trace agent
services = [{
'backend': {
'app': 'django',
'app_type': 'web',
},
'database': {
'app': 'postgres',
'app_type': 'db',
},
}]
# test JSON encoder
response = self.api_json.send_services(services)
ok_(response)
eq_(response.status, 200)
# test Msgpack encoder
response = self.api_msgpack.send_services(services)
ok_(response)
eq_(response.status, 200)
class TestAPITransport(TestCase):
"""
Ensures that traces are properly sent to a local agent. These are part
of integration tests so real calls are triggered and you have to execute
a real trace-agent to let them pass.
"""
def setUp(self):
"""
Create a tracer without workers, while spying the ``send()`` method
"""
# create a new API object to test the transport using synchronous calls
self.tracer = get_dummy_tracer()
self.api_json = API('localhost', 7777, encoder=JSONEncoder())
self.api_msgpack = API('localhost', 7777, encoder=MsgpackEncoder())
def test_send_single_trace(self):
# register a single trace with a span and send them to the trace agent
self.tracer.trace('client.testing').finish()
trace = self.tracer.writer.pop()
traces = [trace]
# test JSON encoder
response = self.api_json.send_traces(traces)
ok_(response)
eq_(response.status, 200)
# test Msgpack encoder
response = self.api_msgpack.send_traces(traces)
ok_(response)
eq_(response.status, 200)
def test_send_multiple_traces(self):
# register some traces and send them to the trace agent
self.tracer.trace('client.testing').finish()
trace_1 = self.tracer.writer.pop()
self.tracer.trace('client.testing').finish()
trace_2 = self.tracer.writer.pop()
traces = [trace_1, trace_2]
# test JSON encoder
response = self.api_json.send_traces(traces)
ok_(response)
eq_(response.status, 200)
# test Msgpack encoder
response = self.api_msgpack.send_traces(traces)
ok_(response)
eq_(response.status, 200)
def test_send_single_trace_multiple_spans(self):
# register some traces and send them to the trace agent
with self.tracer.trace('client.testing'):
self.tracer.trace('client.testing').finish()
trace = self.tracer.writer.pop()
traces = [trace]
# test JSON encoder
response = self.api_json.send_traces(traces)
ok_(response)
eq_(response.status, 200)
# test Msgpack encoder
response = self.api_msgpack.send_traces(traces)
ok_(response)
eq_(response.status, 200)
def test_send_multiple_traces_multiple_spans(self):
# register some traces and send them to the trace agent
with self.tracer.trace('client.testing'):
self.tracer.trace('client.testing').finish()
trace_1 = self.tracer.writer.pop()
with self.tracer.trace('client.testing'):
self.tracer.trace('client.testing').finish()
trace_2 = self.tracer.writer.pop()
traces = [trace_1, trace_2]
# test JSON encoder
response = self.api_json.send_traces(traces)
ok_(response)
eq_(response.status, 200)
# test Msgpack encoder
response = self.api_msgpack.send_traces(traces)
ok_(response)
eq_(response.status, 200)
def test_send_single_service(self):
# register some services and send them to the trace agent
services = [{
'client.service': {
'app': 'django',
'app_type': 'web',
},
}]
# test JSON encoder
response = self.api_json.send_services(services)
ok_(response)
eq_(response.status, 200)
# test Msgpack encoder
response = self.api_msgpack.send_services(services)
ok_(response)
eq_(response.status, 200)
def test_send_service_called_multiple_times(self):
# register some services and send them to the trace agent
services = [{
'backend': {
'app': 'django',
'app_type': 'web',
},
'database': {
'app': 'postgres',
'app_type': 'db',
},
}]
# test JSON encoder
response = self.api_json.send_services(services)
ok_(response)
eq_(response.status, 200)
# test Msgpack encoder
response = self.api_msgpack.send_services(services)
ok_(response)
eq_(response.status, 200)
class TestAPITransport(TestCase):
"""
Ensures that traces are properly sent to a local agent. These are part
of integration tests so real calls are triggered and you have to execute
a real trace-agent to let them pass.
"""
def setUp(self):
"""
Create a tracer without workers, while spying the ``send()`` method
"""
# create a new API object to test the transport using synchronous calls
self.tracer = get_dummy_tracer()
self.api_json = API('localhost', 8126, encoder=JSONEncoder())
self.api_msgpack = API('localhost', 8126, encoder=MsgpackEncoder())
@mock.patch('ddtrace.api.httplib.HTTPConnection')
def test_send_presampler_headers(self, mocked_http):
# register a single trace with a span and send them to the trace agent
self.tracer.trace('client.testing').finish()
trace = self.tracer.writer.pop()
traces = [trace]
# make a call and retrieve the `conn` Mock object
response = self.api_msgpack.send_traces(traces)
request_call = mocked_http.return_value.request
eq_(request_call.call_count, 1)
# retrieve the headers from the mocked request call
expected_headers = {
'Datadog-Meta-Lang': 'python',
'Datadog-Meta-Lang-Interpreter': PYTHON_INTERPRETER,
'Datadog-Meta-Lang-Version': PYTHON_VERSION,
'Datadog-Meta-Tracer-Version': ddtrace.__version__,
'X-Datadog-Trace-Count': '1',
'Content-Type': 'application/msgpack'
}
params, _ = request_call.call_args_list[0]
headers = params[3]
eq_(len(expected_headers), len(headers))
for k, v in expected_headers.items():
eq_(v, headers[k])
@mock.patch('ddtrace.api.httplib.HTTPConnection')
def test_send_presampler_headers_not_in_services(self, mocked_http):
# register some services and send them to the trace agent
services = [{
'client.service': {
'app': 'django',
'app_type': 'web',
},
}]
# make a call and retrieve the `conn` Mock object
response = self.api_msgpack.send_services(services)
request_call = mocked_http.return_value.request
eq_(request_call.call_count, 1)
# retrieve the headers from the mocked request call
expected_headers = {
'Datadog-Meta-Lang': 'python',
'Datadog-Meta-Lang-Interpreter': PYTHON_INTERPRETER,
'Datadog-Meta-Lang-Version': PYTHON_VERSION,
'Datadog-Meta-Tracer-Version': ddtrace.__version__,
'Content-Type': 'application/msgpack'
}
params, _ = request_call.call_args_list[0]
headers = params[3]
eq_(len(expected_headers), len(headers))
for k, v in expected_headers.items():
eq_(v, headers[k])
# retrieve the headers from the mocked request call
params, _ = request_call.call_args_list[0]
headers = params[3]
ok_('X-Datadog-Trace-Count' not in headers.keys())
def test_send_single_trace(self):
# register a single trace with a span and send them to the trace agent
self.tracer.trace('client.testing').finish()
trace = self.tracer.writer.pop()
traces = [trace]
# test JSON encoder
response = self.api_json.send_traces(traces)
ok_(response)
eq_(response.status, 200)
# test Msgpack encoder
response = self.api_msgpack.send_traces(traces)
ok_(response)
eq_(response.status, 200)
def test_send_single_with_wrong_errors(self):
# if the error field is set to True, it must be cast as int so
# that the agent decoder handles that properly without providing
# a decoding error
span = self.tracer.trace('client.testing')
span.error = True
span.finish()
trace = self.tracer.writer.pop()
traces = [trace]
# test JSON encoder
response = self.api_json.send_traces(traces)
ok_(response)
eq_(response.status, 200)
# test Msgpack encoder
response = self.api_msgpack.send_traces(traces)
ok_(response)
eq_(response.status, 200)
def test_send_multiple_traces(self):
# register some traces and send them to the trace agent
self.tracer.trace('client.testing').finish()
trace_1 = self.tracer.writer.pop()
self.tracer.trace('client.testing').finish()
trace_2 = self.tracer.writer.pop()
traces = [trace_1, trace_2]
# test JSON encoder
response = self.api_json.send_traces(traces)
ok_(response)
eq_(response.status, 200)
# test Msgpack encoder
response = self.api_msgpack.send_traces(traces)
ok_(response)
eq_(response.status, 200)
def test_send_single_trace_multiple_spans(self):
# register some traces and send them to the trace agent
with self.tracer.trace('client.testing'):
self.tracer.trace('client.testing').finish()
trace = self.tracer.writer.pop()
traces = [trace]
# test JSON encoder
response = self.api_json.send_traces(traces)
ok_(response)
eq_(response.status, 200)
# test Msgpack encoder
response = self.api_msgpack.send_traces(traces)
ok_(response)
eq_(response.status, 200)
def test_send_multiple_traces_multiple_spans(self):
# register some traces and send them to the trace agent
with self.tracer.trace('client.testing'):
self.tracer.trace('client.testing').finish()
trace_1 = self.tracer.writer.pop()
with self.tracer.trace('client.testing'):
self.tracer.trace('client.testing').finish()
trace_2 = self.tracer.writer.pop()
traces = [trace_1, trace_2]
# test JSON encoder
response = self.api_json.send_traces(traces)
ok_(response)
eq_(response.status, 200)
# test Msgpack encoder
response = self.api_msgpack.send_traces(traces)
ok_(response)
eq_(response.status, 200)
def test_send_single_service(self):
# register some services and send them to the trace agent
services = [{
'client.service': {
'app': 'django',
'app_type': 'web',
},
}]
# test JSON encoder
response = self.api_json.send_services(services)
ok_(response)
eq_(response.status, 200)
# test Msgpack encoder
response = self.api_msgpack.send_services(services)
ok_(response)
eq_(response.status, 200)
def test_send_service_called_multiple_times(self):
# register some services and send them to the trace agent
services = [{
'backend': {
'app': 'django',
'app_type': 'web',
},
'database': {
'app': 'postgres',
'app_type': 'db',
},
}]
# test JSON encoder
response = self.api_json.send_services(services)
ok_(response)
eq_(response.status, 200)
# test Msgpack encoder
response = self.api_msgpack.send_services(services)
ok_(response)
eq_(response.status, 200)
