def test_links(self):
ids_generator = trace_api.RandomIdsGenerator()
other_context1 = trace_api.SpanContext(
trace_id=ids_generator.generate_trace_id(),
span_id=ids_generator.generate_span_id(),
is_remote=False,
)
other_context2 = trace_api.SpanContext(
trace_id=ids_generator.generate_trace_id(),
span_id=ids_generator.generate_span_id(),
is_remote=False,
)
links = (
trace_api.Link(other_context1),
trace_api.Link(other_context2, {"name": "neighbor"}),
)
with self.tracer.start_as_current_span("root", links=links) as root:
self.assertEqual(len(root.links), 2)
self.assertEqual(
root.links[0].context.trace_id, other_context1.trace_id
)
self.assertEqual(
root.links[0].context.span_id, other_context1.span_id
)
self.assertEqual(root.links[0].attributes, None)
self.assertEqual(
root.links[1].context.trace_id, other_context2.trace_id
)
self.assertEqual(
root.links[1].context.span_id, other_context2.span_id
)
self.assertEqual(root.links[1].attributes, {"name": "neighbor"})
def test_sampling_priority_auto_reject(self):
"""Test sampling priority rejected."""
parent_context = get_current_span(
FORMAT.extract(
get_as_list,
{
FORMAT.TRACE_ID_KEY: self.serialized_trace_id,
FORMAT.PARENT_ID_KEY: self.serialized_parent_id,
FORMAT.SAMPLING_PRIORITY_KEY: str(constants.AUTO_REJECT),
},
)).get_context()
self.assertEqual(parent_context.trace_flags, constants.AUTO_REJECT)
child = trace.Span(
"child",
trace_api.SpanContext(
parent_context.trace_id,
trace_api.RandomIdsGenerator().generate_span_id(),
is_remote=False,
trace_flags=parent_context.trace_flags,
trace_state=parent_context.trace_state,
),
parent=parent_context,
)
child_carrier = {}
child_context = set_span_in_context(child)
FORMAT.inject(dict.__setitem__, child_carrier, context=child_context)
self.assertEqual(
child_carrier[FORMAT.SAMPLING_PRIORITY_KEY],
str(constants.AUTO_REJECT),
)
def setUpClass(cls):
ids_generator = trace_api.RandomIdsGenerator()
cls.serialized_trace_id = propagator.format_trace_id(
ids_generator.generate_trace_id())
cls.serialized_parent_id = propagator.format_span_id(
ids_generator.generate_span_id())
cls.serialized_origin = "origin-service"
def get_context_new_carrier(old_carrier, carrier_baggage=None):
ctx = FORMAT.extract(carrier_getter, old_carrier)
if carrier_baggage:
for key, value in carrier_baggage.items():
ctx = baggage.set_baggage(key, value, ctx)
parent_span_context = trace_api.get_current_span(ctx).get_span_context()
parent = trace._Span("parent", parent_span_context)
child = trace._Span(
"child",
trace_api.SpanContext(
parent_span_context.trace_id,
trace_api.RandomIdsGenerator().generate_span_id(),
is_remote=False,
trace_flags=parent_span_context.trace_flags,
trace_state=parent_span_context.trace_state,
),
parent=parent.get_span_context(),
)
new_carrier = {}
ctx = trace_api.set_span_in_context(child, ctx)
FORMAT.inject(dict.__setitem__, new_carrier, context=ctx)
return ctx, new_carrier
def test_span_environment_limits(self):
reload(trace)
tracer = new_tracer()
ids_generator = trace_api.RandomIdsGenerator()
some_links = [
trace_api.Link(
trace_api.SpanContext(
trace_id=ids_generator.generate_trace_id(),
span_id=ids_generator.generate_span_id(),
is_remote=False,
)
)
for _ in range(100)
]
with pytest.raises(ValueError):
with tracer.start_as_current_span("root", links=some_links):
pass
with tracer.start_as_current_span("root") as root:
for idx in range(100):
root.set_attribute("my_attribute_{}".format(idx), 0)
root.add_event("my_event_{}".format(idx))
self.assertEqual(len(root.attributes), 10)
self.assertEqual(len(root.events), 20)
def setUpClass(cls):
ids_generator = trace_api.RandomIdsGenerator()
cls.serialized_trace_id = b3_format.format_trace_id(
ids_generator.generate_trace_id())
cls.serialized_span_id = b3_format.format_span_id(
ids_generator.generate_span_id())
cls.serialized_parent_id = b3_format.format_span_id(
ids_generator.generate_span_id())
def setUpClass(cls):
ids_generator = trace_api.RandomIdsGenerator()
cls.trace_id = ids_generator.generate_trace_id()
cls.span_id = ids_generator.generate_span_id()
cls.parent_span_id = ids_generator.generate_span_id()
cls.serialized_uber_trace_id = _format_uber_trace_id(
cls.trace_id, cls.span_id, cls.parent_span_id, 11
)
def test_context_propagation(self):
"""Test the propagation of Datadog headers."""
parent_span_context = get_current_span(
FORMAT.extract(
carrier_getter,
{
FORMAT.TRACE_ID_KEY: self.serialized_trace_id,
FORMAT.PARENT_ID_KEY: self.serialized_parent_id,
FORMAT.SAMPLING_PRIORITY_KEY: str(constants.AUTO_KEEP),
FORMAT.ORIGIN_KEY: self.serialized_origin,
},
)
).get_span_context()
self.assertEqual(
parent_span_context.trace_id, int(self.serialized_trace_id)
)
self.assertEqual(
parent_span_context.span_id, int(self.serialized_parent_id)
)
self.assertEqual(parent_span_context.trace_flags, constants.AUTO_KEEP)
self.assertEqual(
parent_span_context.trace_state.get(constants.DD_ORIGIN),
self.serialized_origin,
)
self.assertTrue(parent_span_context.is_remote)
child = trace._Span(
"child",
trace_api.SpanContext(
parent_span_context.trace_id,
trace_api.RandomIdsGenerator().generate_span_id(),
is_remote=False,
trace_flags=parent_span_context.trace_flags,
trace_state=parent_span_context.trace_state,
),
parent=parent_span_context,
)
child_carrier = {}
child_context = set_span_in_context(child)
FORMAT.inject(dict.__setitem__, child_carrier, context=child_context)
self.assertEqual(
child_carrier[FORMAT.TRACE_ID_KEY], self.serialized_trace_id
)
self.assertEqual(
child_carrier[FORMAT.PARENT_ID_KEY], str(child.context.span_id)
)
self.assertEqual(
child_carrier[FORMAT.SAMPLING_PRIORITY_KEY],
str(constants.AUTO_KEEP),
)
self.assertEqual(
child_carrier.get(FORMAT.ORIGIN_KEY), self.serialized_origin
)
def __init__(
self,
sampler: sampling.Sampler = sampling.DEFAULT_ON,
resource: Resource = Resource.create({}),
shutdown_on_exit: bool = True,
active_span_processor: Union[SynchronousMultiSpanProcessor,
ConcurrentMultiSpanProcessor] = None,
ids_generator: trace_api.IdsGenerator = None,
):
self._active_span_processor = (active_span_processor
or SynchronousMultiSpanProcessor())
if ids_generator is None:
self.ids_generator = trace_api.RandomIdsGenerator()
else:
self.ids_generator = ids_generator
self.resource = resource
self.sampler = sampler
self._atexit_handler = None
if shutdown_on_exit:
self._atexit_handler = atexit.register(self.shutdown)
class AwsXRayIdsGenerator(trace.IdsGenerator):
"""Generates tracing IDs compatible with the AWS X-Ray tracing service. In
the X-Ray system, the first 32 bits of the `TraceId` are the Unix epoch time
in seconds. Since spans (AWS calls them segments) with an embedded timestamp
more than 30 days ago are rejected, a purely random `TraceId` risks being
rejected by the service.
See: https://docs.aws.amazon.com/xray/latest/devguide/xray-api-sendingdata.html#xray-api-traceids
"""
random_ids_generator = trace.RandomIdsGenerator()
def generate_span_id(self) -> int:
return self.random_ids_generator.generate_span_id()
@staticmethod
def generate_trace_id() -> int:
trace_time = int(time.time())
trace_identifier = random.getrandbits(96)
return (trace_time << 96) + trace_identifier
def get_child_parent_new_carrier(old_carrier):
ctx = FORMAT.extract(carrier_getter, old_carrier)
parent_span_context = trace_api.get_current_span(ctx).get_span_context()
parent = trace._Span("parent", parent_span_context)
child = trace._Span(
"child",
trace_api.SpanContext(
parent_span_context.trace_id,
trace_api.RandomIdsGenerator().generate_span_id(),
is_remote=False,
trace_flags=parent_span_context.trace_flags,
trace_state=parent_span_context.trace_state,
),
parent=parent.get_span_context(),
)
new_carrier = {}
ctx = trace_api.set_span_in_context(child)
FORMAT.inject(dict.__setitem__, new_carrier, context=ctx)
return child, parent, new_carrier
def generate_span_id(self) -> int:
return trace.RandomIdsGenerator().generate_span_id()
