示例#1
0
def test_msgpack_span_property_variations(span):
    refencoder = RefMsgpackEncoder()
    encoder = MsgpackEncoder(1 << 10, 1 << 10)

    # Finish the span to ensure a duration exists.
    span.finish()

    trace = [span]
    encoder.put(trace)
    assert decode(refencoder.encode_traces([trace
                                            ])) == decode(encoder.encode())
示例#2
0
def test_encoder_buffer_item_size_limit():
    max_item_size = 1 << 10
    encoder = MsgpackEncoder(max_item_size << 1, max_item_size)

    span = Span(tracer=None, name="test")
    trace = [span]
    encoder.put(trace)
    trace_size = encoder.size - 1  # This includes the global msgpack array size prefix

    with pytest.raises(BufferItemTooLarge):
        encoder.put([span] * (int(max_item_size / trace_size) + 1))
示例#3
0
def test_custom_msgpack_encode_trace_size(name, service, resource, meta,
                                          metrics, error, span_type):
    encoder = MsgpackEncoder(1 << 20, 1 << 20)
    span = Span(tracer=None, name=name, service=service, resource=resource)
    span.meta = meta
    span.metrics = metrics
    span.error = error
    span.span_type = span_type
    trace = [span, span, span]

    encoder.put(trace)
    assert encoder.size == len(encoder.encode())
示例#4
0
def test_span_types(span, tags):
    refencoder = RefMsgpackEncoder()
    encoder = MsgpackEncoder(1 << 10, 1 << 10)

    span.set_tags(tags)

    # Finish the span to ensure a duration exists.
    span.finish()

    trace = [span]
    encoder.put(trace)
    assert decode(refencoder.encode_traces([trace
                                            ])) == decode(encoder.encode())
示例#5
0
def test_encoder_propagates_dd_origin():
    tracer = DummyTracer()
    encoder = MsgpackEncoder(1 << 20, 1 << 20)
    with tracer.trace("Root") as root:
        root.context.dd_origin = CI_APP_TEST_ORIGIN
        for _ in range(999):
            with tracer.trace("child"):
                pass
    # Ensure encoded trace contains dd_origin tag in all spans
    trace = tracer.writer.pop()
    encoder.put(trace)
    decoded_trace = decode(encoder.encode())[0]
    for span in decoded_trace:
        assert span[b"meta"][b"_dd.origin"] == b"ciapp-test"
示例#6
0
    def test_encode_traces_msgpack_v03(self):
        # test encoding for MsgPack format
        encoder = MsgpackEncoderV03(2 << 10, 2 << 10)
        encoder.put(
            [
                Span(name="client.testing", tracer=None),
                Span(name="client.testing", tracer=None),
            ]
        )
        encoder.put(
            [
                Span(name="client.testing", tracer=None),
                Span(name="client.testing", tracer=None),
            ]
        )

        spans = encoder.encode()
        items = encoder._decode(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"]
示例#7
0
    def __init__(self, *args, **kwargs):
        # original call
        if len(args) == 0 and "agent_url" not in kwargs:
            kwargs["agent_url"] = "http://localhost:8126"

        super(DummyWriter, self).__init__(*args, **kwargs)
        self.spans = []
        self.traces = []
        self.json_encoder = JSONEncoder()
        self.msgpack_encoder = Encoder(4 << 20, 4 << 20)
示例#8
0
def test_encoder_buffer_size_limit():
    buffer_size = 1 << 10
    encoder = MsgpackEncoder(buffer_size, buffer_size)

    trace = [Span(tracer=None, name="test")]
    encoder.put(trace)
    trace_size = encoder.size - 1  # This includes the global msgpack array size prefix

    for _ in range(1, int(buffer_size / trace_size)):
        encoder.put(trace)

    with pytest.raises(BufferFull):
        encoder.put(trace)

    with pytest.raises(BufferFull):
        encoder.put(trace)
示例#9
0
def test_encoding_invalid_data(data):
    encoder = MsgpackEncoderV03(1 << 20, 1 << 20)

    span = Span(tracer=None, name="test")
    for key, value in data.items():
        setattr(span, key, value)

    trace = [span]
    with pytest.raises(TypeError):
        encoder.put(trace)

    assert encoder.encode() is None
示例#10
0
class DummyWriter(AgentWriter):
    """DummyWriter is a small fake writer used for tests. not thread-safe."""
    def __init__(self, *args, **kwargs):
        # original call
        if len(args) == 0 and "agent_url" not in kwargs:
            kwargs["agent_url"] = "http://localhost:8126"

        super(DummyWriter, self).__init__(*args, **kwargs)
        self.spans = []
        self.traces = []
        self.json_encoder = JSONEncoder()
        self.msgpack_encoder = Encoder(4 << 20, 4 << 20)

    def write(self, spans=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
            traces = [spans]
            self.json_encoder.encode_traces(traces)
            self.msgpack_encoder.put(spans)
            self.msgpack_encoder.encode()
            self.spans += spans
            self.traces += traces

    def pop(self):
        # type: () -> List[Span]
        s = self.spans
        self.spans = []
        return s

    def pop_traces(self):
        # type: () -> List[List[Span]]
        traces = self.traces
        self.traces = []
        return traces
示例#11
0
def test_dd_origin_tagging_spans_via_encoder(benchmark, trace_size):
    """Propagate dd_origin tags to all spans in [1, 50, 200, 1000] span trace via Encoder"""
    trace_encoder = MsgpackEncoderV03(4 << 20, 4 << 20)

    tracer = DummyTracer()
    with tracer.trace("pytest-test") as root:
        root.context.dd_origin = CI_APP_TEST_ORIGIN
        for _ in range(trace_size - 1):
            with tracer.trace("") as span:
                span.set_tag("tag", "value")
                pass
    trace = tracer.writer.pop()

    def _(trace):
        trace_encoder.put(trace)
        trace_encoder.encode()

    benchmark(_, trace)

    # Ensure encoded trace contains dd_origin tag in all spans
    trace_encoder.put(trace)
    (decoded_trace, ) = trace_encoder._decode(trace_encoder.encode())
    for span in decoded_trace:
        assert span[b"meta"][b"_dd.origin"] == b"ciapp-test"
示例#12
0
def test_custom_msgpack_encode():
    encoder = MsgpackEncoder(1 << 20, 1 << 20)
    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
    encoder.put(trace)
    assert decode(refencoder.encode_traces([trace
                                            ])) == decode(encoder.encode())

    ref_encoded = refencoder.encode_traces([trace, trace])
    encoder.put(trace)
    encoder.put(trace)
    encoded = encoder.encode()
    assert decode(encoded) == decode(ref_encoded)

    # Empty trace (not that this should be done in practice)
    encoder.put([])
    assert decode(refencoder.encode_traces([[]])) == decode(encoder.encode())

    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()
    encoder.put([s])
    assert decode(refencoder.encode_traces([[s]])) == decode(encoder.encode())