def test_join_encoded_msgpack(self):
# test encoding for MsgPack format
traces = []
traces.append([
Span(name='client.testing', tracer=None),
Span(name='client.testing', tracer=None),
])
traces.append([
Span(name='client.testing', tracer=None),
Span(name='client.testing', tracer=None),
])
encoder = MsgpackEncoder()
# Encode each individual trace on it's own
encoded_traces = [encoder.encode_trace(trace) for trace in traces]
# Join the encoded traces together
data = encoder.join_encoded(encoded_traces)
# Parse the encoded data
items = msgpack.unpackb(data)
# test the encoded output that should be a string
# and the output must be flatten
assert isinstance(data, msgpack_type)
assert len(items) == 2
assert len(items[0]) == 2
assert len(items[1]) == 2
for i in range(2):
for j in range(2):
assert b'client.testing' == items[i][j][b'name']
def test_encode_traces_msgpack(self):
# test encoding for MsgPack format
traces = []
traces.append([
Span(name='client.testing', tracer=None),
Span(name='client.testing', tracer=None),
])
traces.append([
Span(name='client.testing', tracer=None),
Span(name='client.testing', tracer=None),
])
encoder = MsgpackEncoder()
spans = encoder.encode_traces(traces)
items = msgpack.unpackb(spans)
# test the encoded output that should be a string
# and the output must be flatten
ok_(isinstance(spans, msgpack_type))
eq_(len(items), 2)
eq_(len(items[0]), 2)
eq_(len(items[1]), 2)
for i in range(2):
for j in range(2):
eq_(b'client.testing', items[i][j][b'name'])
def test_encode_traces_msgpack(self):
# test encoding for MsgPack format
traces = []
traces.append([
Span(name='client.testing', tracer=None),
Span(name='client.testing', tracer=None),
])
traces.append([
Span(name='client.testing', tracer=None),
Span(name='client.testing', tracer=None),
])
encoder = MsgpackEncoder()
spans = encoder.encode_traces(traces)
items = msgpack.unpackb(spans)
# test the encoded output that should be a string
# and the output must be flatten
assert isinstance(spans, msgpack_type)
assert len(items) == 2
assert len(items[0]) == 2
assert len(items[1]) == 2
for i in range(2):
for j in range(2):
assert b'client.testing' == items[i][j][b'name']
def __init__(self):
# original call
super(DummyWriter, self).__init__()
# dummy components
self.spans = []
self.services = {}
self.json_encoder = JSONEncoder()
self.msgpack_encoder = MsgpackEncoder()
def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
super().__init__(*args, **kwargs)
# Dummy components.
self.spans: typing.List[Span] = []
self.traces: typing.List[Trace] = []
self.services: typing.Dict[str, Service] = {}
self.json_encoder = JSONEncoder()
self.msgpack_encoder = MsgpackEncoder()
def test_msgpack_span_property_variations(span):
refencoder = RefMsgpackEncoder()
encoder = MsgpackEncoder()
# Finish the span to ensure a duration exists.
span.finish()
trace = [span]
assert decode(refencoder.encode_trace(trace)) == decode(encoder.encode_trace(trace))
def test_span_types(span, tags):
refencoder = RefMsgpackEncoder()
encoder = MsgpackEncoder()
span.set_tags(tags)
# Finish the span to ensure a duration exists.
span.finish()
trace = [span]
assert decode(refencoder.encode_trace(trace)) == decode(encoder.encode_trace(trace))
class DummyWriter(AgentWriter):
"""DummyWriter is a small fake writer used for tests. not thread-safe."""
def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
super().__init__(*args, **kwargs)
# Dummy components.
self.spans: typing.List[Span] = []
self.traces: typing.List[Trace] = []
self.services: typing.Dict[str, Service] = {}
self.json_encoder = JSONEncoder()
self.msgpack_encoder = MsgpackEncoder()
def write(self,
spans: typing.List[Span] = None,
services: typing.List[Service] = None) -> None:
if spans:
# The traces encoding expect a list of traces so we
# put spans in a list like we do in the real execution path
# with both encoders.
trace = [spans]
self.json_encoder.encode_traces(trace)
self.msgpack_encoder.encode_traces(trace)
self.spans += spans
self.traces += trace
if services:
self.json_encoder.encode_services(services)
self.msgpack_encoder.encode_services(services)
self.services.update(services)
def pop(self) -> typing.List[Span]:
# Dummy method.
spans = self.spans
self.spans = []
return spans
def pop_traces(self) -> typing.List[Trace]:
# Dummy method.
traces = self.traces
self.traces = []
return traces
def pop_services(self) -> typing.Dict[str, Service]:
# Dummy method.
# Setting service info has been deprecated,
# we want to make sure nothing ever gets written here.
assert self.services == {}
services = self.services
self.services = {}
return services
class DummyWriter(AgentWriter):
"""
# NB: This is coy fo DummyWriter class from ddtraces tests suite
DummyWriter is a small fake writer used for tests. not thread-safe.
"""
def __init__(self):
# original call
super(DummyWriter, self).__init__()
# dummy components
self.spans = []
self.traces = []
self.services = {}
self.json_encoder = JSONEncoder()
self.msgpack_encoder = MsgpackEncoder()
def write(self, spans=None, services=None):
if spans:
# the traces encoding expect a list of traces so we
# put spans in a list like we do in the real execution path
# with both encoders
trace = [spans]
self.json_encoder.encode_traces(trace)
self.msgpack_encoder.encode_traces(trace)
self.spans += spans
self.traces += trace
if services:
self.json_encoder.encode_services(services)
self.msgpack_encoder.encode_services(services)
self.services.update(services)
def pop(self):
# dummy method
s = self.spans
self.spans = []
return s
def pop_traces(self):
# dummy method
traces = self.traces
self.traces = []
return traces
def pop_services(self):
# dummy method
s = self.services
self.services = {}
return s
class DummyWriter(AgentWriter):
"""DummyWriter is a small fake writer used for tests. not thread-safe."""
def __init__(self, *args, **kwargs):
# original call
super(DummyWriter, self).__init__(*args, **kwargs)
# dummy components
self.spans = []
self.traces = []
self.services = {}
self.json_encoder = JSONEncoder()
self.msgpack_encoder = MsgpackEncoder()
def write(self, spans=None, services=None):
if spans:
# the traces encoding expect a list of traces so we
# put spans in a list like we do in the real execution path
# with both encoders
trace = [spans]
self.json_encoder.encode_traces(trace)
self.msgpack_encoder.encode_traces(trace)
self.spans += spans
self.traces += trace
if services:
self.json_encoder.encode_services(services)
self.msgpack_encoder.encode_services(services)
self.services.update(services)
def pop(self):
# dummy method
s = self.spans
self.spans = []
return s
def pop_traces(self):
# dummy method
traces = self.traces
self.traces = []
return traces
def pop_services(self):
# dummy method
# Setting service info has been deprecated, we want to make sure nothing ever gets written here
assert self.services == {}
s = self.services
self.services = {}
return s
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())
class DummyWriter(AgentWriter):
""" DummyWriter is a small fake writer used for tests. not thread-safe. """
def __init__(self):
# original call
super(DummyWriter, self).__init__()
# dummy components
self.spans = []
self.traces = []
self.services = {}
self.json_encoder = JSONEncoder()
self.msgpack_encoder = MsgpackEncoder()
def write(self, spans=None, services=None):
if spans:
# the traces encoding expect a list of traces so we
# put spans in a list like we do in the real execution path
# with both encoders
trace = [spans]
self.json_encoder.encode_traces(trace)
self.msgpack_encoder.encode_traces(trace)
self.spans += spans
self.traces += trace
if services:
self.json_encoder.encode_services(services)
self.msgpack_encoder.encode_services(services)
self.services.update(services)
def pop(self):
# dummy method
s = self.spans
self.spans = []
return s
def pop_traces(self):
# dummy method
traces = self.traces
self.traces = []
return traces
def pop_services(self):
# dummy method
s = self.services
self.services = {}
return s
def __init__(self):
# original call
super(DummyWriter, self).__init__()
# dummy components
self.spans = []
self.traces = []
self.services = {}
self.json_encoder = JSONEncoder()
self.msgpack_encoder = MsgpackEncoder()
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())
def test_custom_msgpack_encode():
encoder = MsgpackEncoder()
refencoder = RefMsgpackEncoder()
trace = gen_trace(nspans=50)
# Note that we assert on the decoded versions because the encoded
# can vary due to non-deterministic map key/value positioning
assert decode(refencoder.encode_trace(trace)) == decode(
encoder.encode_trace(trace))
ref_encoded = refencoder.encode_traces([trace, trace])
encoded = encoder.encode_traces([trace, trace])
assert decode(encoded) == decode(ref_encoded)
# Empty trace (not that this should be done in practice)
assert decode(refencoder.encode_trace([])) == decode(
encoder.encode_trace([]))
s = Span(None, None)
# Need to .finish() to have a duration since the old implementation will not encode
# duration_ns, the new one will encode as None
s.finish()
assert decode(refencoder.encode_trace([s])) == decode(
encoder.encode_trace([s]))
def test_encode_traces_msgpack(self):
# test encoding for JSON format
traces = []
traces.append([
Span(name='client.testing', tracer=None),
Span(name='client.testing', tracer=None),
])
traces.append([
Span(name='client.testing', tracer=None),
Span(name='client.testing', tracer=None),
])
encoder = MsgpackEncoder()
spans = encoder.encode_traces(traces)
items = msgpack.unpackb(spans)
# test the encoded output that should be a string
# and the output must be flatten
ok_(isinstance(spans, msgpack_type))
eq_(len(items), 2)
eq_(len(items[0]), 2)
eq_(len(items[1]), 2)
def test_custom_msgpack_join_encoded():
encoder = MsgpackEncoder()
refencoder = RefMsgpackEncoder()
trace = gen_trace(nspans=50)
ref = refencoder.join_encoded([refencoder.encode_trace(trace) for _ in range(10)])
custom = encoder.join_encoded([encoder.encode_trace(trace) for _ in range(10)])
assert decode(ref) == decode(custom)
ref = refencoder.join_encoded([refencoder.encode_trace(trace) for _ in range(1)])
custom = encoder.join_encoded([encoder.encode_trace(trace) for _ in range(1)])
assert decode(ref) == decode(custom)
import msgpack
from msgpack.fallback import Packer
import pytest
from ddtrace.encoding import _EncoderBase, MsgpackEncoder
from tests.tracer.test_encoders import RefMsgpackEncoder, gen_trace
msgpack_encoder = RefMsgpackEncoder()
trace_encoder = MsgpackEncoder()
class PPMsgpackEncoder(_EncoderBase):
content_type = "application/msgpack"
@staticmethod
def encode(obj):
return Packer().pack(obj)
@staticmethod
def decode(data):
return msgpack.unpackb(data, raw=True)
trace_large = gen_trace(nspans=1000)
trace_small = gen_trace(nspans=50, key_size=10, ntags=5, nmetrics=4)
@pytest.mark.benchmark(group="encoding.join_encoded", min_time=0.005)
def test_join_encoded(benchmark):
benchmark(
