def extract(cls, get_from_carrier, carrier):
trace_id_list = get_from_carrier(carrier, cls.TRACE_ID_KEY)
span_id_list = get_from_carrier(carrier, cls.SPAN_ID_KEY)
if not trace_id_list or not span_id_list:
return trace.INVALID_SPAN_CONTEXT
return trace.SpanContext(trace_id=int(trace_id_list[0]),
span_id=int(span_id_list[0]))
def _create_parent_span(trace_flags: trace.TraceFlags,
is_remote=False) -> trace.DefaultSpan:
return trace.DefaultSpan(
trace.SpanContext(
0xDEADBEEF,
0xDEADBEF0,
is_remote=is_remote,
trace_flags=trace_flags,
))
def test_max_tag_value_length(self):
span = trace._Span(
name="span",
resource=Resource(
attributes={
"key_resource": "some_resource some_resource some_more_resource"
}
),
context=trace_api.SpanContext(
trace_id=0x000000000000000000000000DEADBEEF,
span_id=0x00000000DEADBEF0,
is_remote=False,
),
)
span.start()
span.set_attribute("key_bool", False)
span.set_attribute("key_string", "hello_world hello_world hello_world")
span.set_attribute("key_float", 111.22)
span.set_attribute("key_int", 1100)
span.set_attribute("key_tuple", ("tuple_element", "tuple_element2"))
span.end()
translate = Translate([span])
# does not truncate by default
# pylint: disable=protected-access
spans = translate._translate(pb_translator.ProtobufTranslator("svc"))
tags_by_keys = {
tag.key: tag.v_str
for tag in spans[0].tags
if tag.v_type == model_pb2.ValueType.STRING
}
self.assertEqual(
"hello_world hello_world hello_world", tags_by_keys["key_string"]
)
self.assertEqual(
"('tuple_element', 'tuple_element2')", tags_by_keys["key_tuple"]
)
self.assertEqual(
"some_resource some_resource some_more_resource",
tags_by_keys["key_resource"],
)
# truncates when max_tag_value_length is passed
# pylint: disable=protected-access
spans = translate._translate(
pb_translator.ProtobufTranslator("svc", max_tag_value_length=5)
)
tags_by_keys = {
tag.key: tag.v_str
for tag in spans[0].tags
if tag.v_type == model_pb2.ValueType.STRING
}
self.assertEqual("hello", tags_by_keys["key_string"])
self.assertEqual("('tup", tags_by_keys["key_tuple"])
self.assertEqual("some_", tags_by_keys["key_resource"])
def test_default_off(self):
no_record_default_off = sampling.DEFAULT_OFF.should_sample(
trace.SpanContext(0xDEADBEEF, 0xDEADBEF0, trace_flags=TO_DEFAULT),
0xDEADBEF1,
0xDEADBEF2,
"unsampled parent, sampling off",
)
self.assertFalse(no_record_default_off.sampled)
self.assertEqual(no_record_default_off.attributes, {})
sampled_default_off = sampling.DEFAULT_OFF.should_sample(
trace.SpanContext(0xDEADBEEF, 0xDEADBEF0, trace_flags=TO_SAMPLED),
0xDEADBEF1,
0xDEADBEF2,
"sampled parent, sampling off",
)
self.assertTrue(sampled_default_off.sampled)
self.assertEqual(sampled_default_off.attributes, {})
def test_always_on(self):
no_record_always_on = sampling.ALWAYS_ON.should_sample(
trace.SpanContext(0xDEADBEEF, 0xDEADBEF0, trace_flags=TO_DEFAULT),
0xDEADBEF1,
0xDEADBEF2,
"unsampled parent, sampling on",
)
self.assertTrue(no_record_always_on.sampled)
self.assertEqual(no_record_always_on.attributes, {})
sampled_always_on = sampling.ALWAYS_ON.should_sample(
trace.SpanContext(0xDEADBEEF, 0xDEADBEF0, trace_flags=TO_SAMPLED),
0xDEADBEF1,
0xDEADBEF2,
"sampled parent, sampling on",
)
self.assertTrue(sampled_always_on.sampled)
self.assertEqual(sampled_always_on.attributes, {})
def test_span_context(self):
"""Test construction of `SpanContextShim` objects."""
otel_context = trace.SpanContext(1234, 5678, is_remote=False)
context = SpanContextShim(otel_context)
self.assertIsInstance(context, opentracing.SpanContext)
self.assertEqual(context.unwrap().trace_id, 1234)
self.assertEqual(context.unwrap().span_id, 5678)
def test_inject_binary(self):
"""Test `inject()` method for Format.BINARY."""
otel_context = trace.SpanContext(trace_id=1220, span_id=7478)
context = opentracingshim.SpanContextShim(otel_context)
# Verify exception for non supported binary format.
with self.assertRaises(opentracing.UnsupportedFormatException):
self.shim.inject(context, opentracing.Format.BINARY, bytearray())
def extract(
self,
get_from_carrier: Getter[HTTPTextFormatT],
carrier: HTTPTextFormatT,
context: typing.Optional[Context] = None,
) -> Context:
trace_id = format_trace_id(trace.INVALID_TRACE_ID)
span_id = format_span_id(trace.INVALID_SPAN_ID)
sampled = "0"
flags = None
single_header = _extract_first_element(
get_from_carrier(carrier, self.SINGLE_HEADER_KEY))
if single_header:
# The b3 spec calls for the sampling state to be
# "deferred", which is unspecified. This concept does not
# translate to SpanContext, so we set it as recorded.
sampled = "1"
fields = single_header.split("-", 4)
if len(fields) == 1:
sampled = fields[0]
elif len(fields) == 2:
trace_id, span_id = fields
elif len(fields) == 3:
trace_id, span_id, sampled = fields
elif len(fields) == 4:
trace_id, span_id, sampled, _ = fields
else:
return set_span_in_context(trace.INVALID_SPAN)
else:
trace_id = (_extract_first_element(
get_from_carrier(carrier, self.TRACE_ID_KEY)) or trace_id)
span_id = (_extract_first_element(
get_from_carrier(carrier, self.SPAN_ID_KEY)) or span_id)
sampled = (_extract_first_element(
get_from_carrier(carrier, self.SAMPLED_KEY)) or sampled)
flags = (_extract_first_element(
get_from_carrier(carrier, self.FLAGS_KEY)) or flags)
options = 0
# The b3 spec provides no defined behavior for both sample and
# flag values set. Since the setting of at least one implies
# the desire for some form of sampling, propagate if either
# header is set to allow.
if sampled in self._SAMPLE_PROPAGATE_VALUES or flags == "1":
options |= trace.TraceFlags.SAMPLED
return set_span_in_context(
trace.DefaultSpan(
trace.SpanContext(
# trace an span ids are encoded in hex, so must be converted
trace_id=int(trace_id, 16),
span_id=int(span_id, 16),
is_remote=True,
trace_flags=trace.TraceFlags(options),
trace_state=trace.TraceState(),
)))
def test_default_off(self):
context = trace.set_span_in_context(
trace.DefaultSpan(
trace.SpanContext(
0xDEADBEEF,
0xDEADBEF0,
is_remote=False,
trace_flags=TO_DEFAULT,
)))
no_record_default_off = sampling.DEFAULT_OFF.should_sample(
context,
0xDEADBEF1,
0xDEADBEF2,
"unsampled parent, sampling off",
)
self.assertFalse(no_record_default_off.decision.is_sampled())
self.assertEqual(no_record_default_off.attributes, {})
context = trace.set_span_in_context(
trace.DefaultSpan(
trace.SpanContext(
0xDEADBEEF,
0xDEADBEF0,
is_remote=False,
trace_flags=TO_SAMPLED,
)))
sampled_default_off = sampling.DEFAULT_OFF.should_sample(
context,
0xDEADBEF1,
0xDEADBEF2,
{"sampled parent": "sampling on"},
)
self.assertTrue(sampled_default_off.decision.is_sampled())
self.assertEqual(sampled_default_off.attributes,
{"sampled parent": "sampling on"})
default_off = sampling.DEFAULT_OFF.should_sample(
None,
0xDEADBEF1,
0xDEADBEF2,
"unsampled parent, sampling off",
)
self.assertFalse(default_off.decision.is_sampled())
self.assertEqual(default_off.attributes, {})
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 test_inject_http_headers(self):
"""Test `inject()` method for Format.HTTP_HEADERS."""
otel_context = trace.SpanContext(trace_id=1220, span_id=7478)
context = opentracingshim.SpanContextShim(otel_context)
headers = {}
self.shim.inject(context, opentracing.Format.HTTP_HEADERS, headers)
self.assertEqual(headers[MockHTTPTextFormat.TRACE_ID_KEY], str(1220))
self.assertEqual(headers[MockHTTPTextFormat.SPAN_ID_KEY], str(7478))
def test_get_parent_id_from_span(self):
parent_id = 0x00000000DEADBEF0
self.assertEqual(
parent_id,
self.get_encoder_default()._get_parent_id(
trace._Span(
name="test-span",
context=trace_api.SpanContext(
0x000000000000000000000000DEADBEEF,
0x04BF92DEEFC58C92,
is_remote=False,
),
parent=trace_api.SpanContext(
0x0000000000000000000000AADEADBEEF,
parent_id,
is_remote=False,
),
)),
)
def test_ctor(self):
context = trace.SpanContext(
1,
1,
is_remote=False,
trace_flags=trace.DEFAULT_TRACE_OPTIONS,
trace_state=trace.DEFAULT_TRACE_STATE,
)
span = trace.NonRecordingSpan(context)
self.assertEqual(context, span.get_span_context())
def test_encode_id_zero_padding(self):
trace_id = 0x0E0C63257DE34C926F9EFCD03927272E
span_id = 0x04BF92DEEFC58C92
parent_id = 0x0AAAAAAAAAAAAAAA
start_time = 683647322 * 10**9 # in ns
duration = 50 * 10**6
end_time = start_time + duration
otel_span = trace._Span(
name=TEST_SERVICE_NAME,
context=trace_api.SpanContext(
trace_id,
span_id,
is_remote=False,
trace_flags=TraceFlags(TraceFlags.SAMPLED),
),
parent=trace_api.SpanContext(trace_id, parent_id, is_remote=False),
resource=trace.Resource({}),
)
otel_span.start(start_time=start_time)
otel_span.end(end_time=end_time)
expected_output = [{
"traceId":
format_trace_id(trace_id),
"id":
format_span_id(span_id),
"name":
TEST_SERVICE_NAME,
"timestamp":
JsonV1Encoder._nsec_to_usec_round(start_time),
"duration":
JsonV1Encoder._nsec_to_usec_round(duration),
"debug":
True,
"parentId":
format_span_id(parent_id),
}]
self.assertEqual(
json.dumps(expected_output),
JsonV1Encoder().serialize([otel_span], NodeEndpoint()),
)
def test_origin(self):
trace_id = 0x000000000000000000000000DEADBEEF
trace_state = trace_api.TraceState([(datadog.constants.DD_ORIGIN,
"origin-service")])
parent_span_ctx = trace_api.SpanContext(
trace_id=trace_id,
span_id=0x1,
is_remote=False,
trace_state=trace_state,
)
child_span_ctx = trace_api.SpanContext(
trace_id=trace_id,
span_id=0x2,
is_remote=False,
trace_state=trace_state,
)
root_span = trace._Span(name="root",
context=parent_span_ctx,
parent=None)
child_span = trace._Span(name="child",
context=child_span_ctx,
parent=parent_span_ctx)
root_span.start()
child_span.start()
child_span.end()
root_span.end()
# pylint: disable=protected-access
exporter = datadog.DatadogSpanExporter()
datadog_spans = [
span.to_dict()
for span in exporter._translate_to_datadog([root_span, child_span])
]
self.assertEqual(len(datadog_spans), 2)
actual = [
span["meta"].get(datadog.constants.DD_ORIGIN)
if "meta" in span else None for span in datadog_spans
]
expected = ["origin-service", None]
self.assertListEqual(actual, expected)
def setUp(self):
# create and save span to be used in tests
context = trace_api.SpanContext(
trace_id=0x000000000000000000000000DEADBEEF,
span_id=0x00000000DEADBEF0,
)
self._test_span = trace.Span("test_span", context=context)
self._test_span.start()
self._test_span.end()
def test_export_protobuf_max_tag_length(self):
service_name = "test-service"
span_context = trace_api.SpanContext(
0x0E0C63257DE34C926F9EFCD03927272E,
0x04BF92DEEFC58C92,
is_remote=False,
trace_flags=TraceFlags(TraceFlags.SAMPLED),
)
span = trace._Span(name="test-span", context=span_context,)
span.start()
span.resource = Resource({})
# added here to preserve order
span.set_attribute("k1", "v" * 500)
span.set_attribute("k2", "v" * 50)
span.set_status(Status(StatusCode.ERROR, "Example description"))
span.end()
exporter = ZipkinSpanExporter(
service_name, transport_format=TRANSPORT_FORMAT_PROTOBUF,
)
mock_post = MagicMock()
with patch("requests.post", mock_post):
mock_post.return_value = MockResponse(200)
status = exporter.export([span])
self.assertEqual(SpanExportResult.SUCCESS, status)
# pylint: disable=unsubscriptable-object
kwargs = mock_post.call_args[1]
actual_spans = zipkin_pb2.ListOfSpans.FromString(kwargs["data"])
span_tags = actual_spans.spans[0].tags
self.assertEqual(len(span_tags["k1"]), 128)
self.assertEqual(len(span_tags["k2"]), 50)
exporter = ZipkinSpanExporter(
service_name,
transport_format=TRANSPORT_FORMAT_PROTOBUF,
max_tag_value_length=2,
)
mock_post = MagicMock()
with patch("requests.post", mock_post):
mock_post.return_value = MockResponse(200)
status = exporter.export([span])
self.assertEqual(SpanExportResult.SUCCESS, status)
# pylint: disable=unsubscriptable-object
kwargs = mock_post.call_args[1]
actual_spans = zipkin_pb2.ListOfSpans.FromString(kwargs["data"])
span_tags = actual_spans.spans[0].tags
self.assertEqual(len(span_tags["k1"]), 2)
self.assertEqual(len(span_tags["k2"]), 2)
def extract(
self,
getter: Getter[TextMapPropagatorT],
carrier: TextMapPropagatorT,
context: typing.Optional[Context] = None,
) -> Context:
trace_header_list = getter.get(carrier, TRACE_HEADER_KEY)
if not trace_header_list or len(trace_header_list) != 1:
return trace.set_span_in_context(
trace.INVALID_SPAN, context=context
)
trace_header = trace_header_list[0]
if not trace_header:
return trace.set_span_in_context(
trace.INVALID_SPAN, context=context
)
try:
(
trace_id,
span_id,
sampled,
) = AwsXRayFormat._extract_span_properties(trace_header)
except AwsParseTraceHeaderError as err:
_logger.debug(err.message)
return trace.set_span_in_context(
trace.INVALID_SPAN, context=context
)
options = 0
if sampled:
options |= trace.TraceFlags.SAMPLED
span_context = trace.SpanContext(
trace_id=trace_id,
span_id=span_id,
is_remote=True,
trace_flags=trace.TraceFlags(options),
trace_state=trace.TraceState(),
)
if not span_context.is_valid:
_logger.debug(
"Invalid Span Extracted. Insertting INVALID span into provided context."
)
return trace.set_span_in_context(
trace.INVALID_SPAN, context=context
)
return trace.set_span_in_context(
trace.DefaultSpan(span_context), context=context
)
def test_links(self):
other_context1 = trace_api.SpanContext(
trace_id=trace.generate_trace_id(),
span_id=trace.generate_span_id(),
is_remote=False,
)
other_context2 = trace_api.SpanContext(
trace_id=trace.generate_trace_id(),
span_id=trace.generate_span_id(),
is_remote=False,
)
other_context3 = trace_api.SpanContext(
trace_id=trace.generate_trace_id(),
span_id=trace.generate_span_id(),
is_remote=False,
)
links = [
trace_api.Link(other_context1),
trace_api.Link(other_context2, {"name": "neighbor"}),
trace_api.Link(other_context3, {"component": "http"}),
]
with self.tracer.start_as_current_span("root", links=links) as root:
self.assertEqual(len(root.links), 3)
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, {})
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"})
self.assertEqual(
root.links[2].context.span_id, other_context3.span_id
)
self.assertEqual(root.links[2].attributes, {"component": "http"})
def test_always_off(self):
no_record_always_off = sampling.ALWAYS_OFF.should_sample(
trace.SpanContext(0xDEADBEEF, 0xDEADBEF0,
trace_options=TO_DEFAULT),
0xDEADBEF1,
0xDEADBEF2,
"unsampled parent, sampling off",
)
self.assertFalse(no_record_always_off.sampled)
self.assertEqual(no_record_always_off.attributes, {})
sampled_always_on = sampling.ALWAYS_OFF.should_sample(
trace.SpanContext(0xDEADBEEF, 0xDEADBEF0,
trace_options=TO_SAMPLED),
0xDEADBEF1,
0xDEADBEF2,
"sampled parent, sampling off",
)
self.assertFalse(sampled_always_on.sampled)
self.assertEqual(sampled_always_on.attributes, {})
def test_inject_text_map(self):
"""Test `inject()` method for Format.TEXT_MAP."""
otel_context = trace.SpanContext(trace_id=1220, span_id=7478)
context = opentracingshim.SpanContextShim(otel_context)
# Verify Format.TEXT_MAP
text_map = {}
self.shim.inject(context, opentracing.Format.TEXT_MAP, text_map)
self.assertEqual(text_map[MockHTTPTextFormat.TRACE_ID_KEY], str(1220))
self.assertEqual(text_map[MockHTTPTextFormat.SPAN_ID_KEY], str(7478))
def _create_parent_span(trace_flags: trace.TraceFlags,
is_remote=False,
trace_state=None) -> trace.NonRecordingSpan:
return trace.NonRecordingSpan(
trace.SpanContext(
0xDEADBEEF,
0xDEADBEF0,
is_remote=is_remote,
trace_flags=trace_flags,
trace_state=trace_state,
))
def test_get_parent_id_from_span_context(self):
parent_id = 0x00000000DEADBEF0
self.assertEqual(
parent_id,
self.get_encoder_default()._get_parent_id(
trace_api.SpanContext(
trace_id=0x000000000000000000000000DEADBEEF,
span_id=parent_id,
is_remote=False,
), ),
)
def test_span_id_validity(self):
span_id_max = int("f" * 16, 16)
trace_id = 1
# valid span IDs
sc = trace.SpanContext(trace_id, span_id_max, is_remote=False)
self.assertTrue(sc.is_valid)
sc = trace.SpanContext(trace_id, 1, is_remote=False)
self.assertTrue(sc.is_valid)
# invalid span IDs
sc = trace.SpanContext(trace_id, 0, is_remote=False)
self.assertFalse(sc.is_valid)
sc = trace.SpanContext(trace_id, -1, is_remote=False)
self.assertFalse(sc.is_valid)
sc = trace.SpanContext(trace_id, span_id_max + 1, is_remote=False)
self.assertFalse(sc.is_valid)
def test_encode_debug(self):
self.assertFalse(
self.get_encoder_default()._encode_debug(
trace_api.SpanContext(
trace_id=0x000000000000000000000000DEADBEEF,
span_id=0x00000000DEADBEF0,
is_remote=False,
trace_flags=TraceFlags(TraceFlags.DEFAULT),
)
)
)
self.assertTrue(
self.get_encoder_default()._encode_debug(
trace_api.SpanContext(
trace_id=0x000000000000000000000000DEADBEEF,
span_id=0x00000000DEADBEF0,
is_remote=False,
trace_flags=TraceFlags(TraceFlags.SAMPLED),
)
)
)
def setUp(self):
# create and save span to be used in tests
context = trace_api.SpanContext(
trace_id=0x000000000000000000000000DEADBEEF,
span_id=0x00000000DEADBEF0,
is_remote=False,
)
self._test_span = trace._Span("test_span", context=context)
self._test_span.start()
self._test_span.end()
# pylint: disable=protected-access
Configuration._reset()
def test_trace_id_validity(self):
trace_id_max_value = int("f" * 32, 16)
span_id = 1
# valid trace IDs
sc = trace.SpanContext(trace_id_max_value, span_id, is_remote=False)
self.assertTrue(sc.is_valid)
sc = trace.SpanContext(1, span_id, is_remote=False)
self.assertTrue(sc.is_valid)
# invalid trace IDs
sc = trace.SpanContext(0, span_id, is_remote=False)
self.assertFalse(sc.is_valid)
sc = trace.SpanContext(-1, span_id, is_remote=False)
self.assertFalse(sc.is_valid)
sc = trace.SpanContext(trace_id_max_value + 1,
span_id,
is_remote=False)
self.assertFalse(sc.is_valid)
def _create_start_and_end_span(name, span_processor):
span = trace._Span(
name,
trace_api.SpanContext(
0xDEADBEEF,
0xDEADBEEF,
is_remote=False,
trace_flags=trace_api.TraceFlags(trace_api.TraceFlags.SAMPLED),
),
span_processor=span_processor,
)
span.start()
span.end()
def extract(
self,
carrier: textmap.CarrierT,
context: typing.Optional[Context] = None,
getter: textmap.Getter = textmap.default_getter,
) -> Context:
"""Extracts SpanContext from the carrier.
See `opentelemetry.propagators.textmap.TextMapPropagator.extract`
"""
if context is None:
context = Context()
header = getter.get(carrier, self._TRACEPARENT_HEADER_NAME)
if not header:
return context
match = re.search(self._TRACEPARENT_HEADER_FORMAT_RE, header[0])
if not match:
return context
version = match.group(1)
trace_id = match.group(2)
span_id = match.group(3)
trace_flags = match.group(4)
if trace_id == "0" * 32 or span_id == "0" * 16:
return context
if version == "00":
if match.group(5):
return context
if version == "ff":
return context
tracestate_headers = getter.get(carrier, self._TRACESTATE_HEADER_NAME)
if tracestate_headers is None:
tracestate = None
else:
tracestate = TraceState.from_header(tracestate_headers)
span_context = trace.SpanContext(
trace_id=int(trace_id, 16),
span_id=int(span_id, 16),
is_remote=True,
trace_flags=trace.TraceFlags(trace_flags),
trace_state=tracestate,
)
return trace.set_span_in_context(trace.NonRecordingSpan(span_context),
context)
def test_probability_sampler(self):
sampler = sampling.ProbabilitySampler(0.5)
# Check that we sample based on the trace ID if the parent context is
# null
self.assertTrue(
sampler.should_sample(None, 0x7FFFFFFFFFFFFFFF, 0xDEADBEEF,
"span name").sampled)
self.assertFalse(
sampler.should_sample(None, 0x8000000000000000, 0xDEADBEEF,
"span name").sampled)
# Check that the sampling decision matches the parent context if given,
# and that the sampler ignores the trace ID
self.assertFalse(
sampler.should_sample(
trace.SpanContext(
0xDEADBEF0,
0xDEADBEF1,
is_remote=False,
trace_flags=TO_DEFAULT,
),
0x7FFFFFFFFFFFFFFF,
0xDEADBEEF,
"span name",
).sampled)
self.assertTrue(
sampler.should_sample(
trace.SpanContext(
0xDEADBEF0,
0xDEADBEF1,
is_remote=False,
trace_flags=TO_SAMPLED,
),
0x8000000000000000,
0xDEADBEEF,
"span name",
).sampled)
