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(