From 2fc65109f5904b527daeb2718579f86ba2026188 Mon Sep 17 00:00:00 2001 From: Rashmi-K-A Date: Thu, 8 Oct 2020 10:33:23 +0530 Subject: [PATCH 1/7] adding support for Jaeger propagator --- .../sdk/trace/propagation/jaeger_format.py | 68 +++++++++++++++++++ 1 file changed, 68 insertions(+) create mode 100644 opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_format.py diff --git a/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_format.py b/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_format.py new file mode 100644 index 00000000000..e96190be985 --- /dev/null +++ b/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_format.py @@ -0,0 +1,68 @@ +# Copyright The OpenTelemetry Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import typing + +import opentelemetry.trace as trace +from opentelemetry.context import Context +from opentelemetry.trace.propagation.textmap import ( + Getter, + Setter, + TextMapPropagator, + TextMapPropagatorT, +) +from opentelemetry import baggage + +class JaegerFormat(TextMapPropagator): + """Propagator for the Jaeger format. + + See: https://www.jaegertracing.io/docs/1.19/client-libraries/#propagation-format + """ + + TRACE_ID_KEY = 'uber-trace-id' + def inject( + self, + set_in_carrier: Setter[TextMapPropagatorT], + carrier: TextMapPropagatorT, + context: typing.Optional[Context] = None, + ) -> None: + span = trace.get_current_span(context=context) + span_context = span.get_context() + if span_context == trace.INVALID_SPAN_CONTEXT: + return + + # set span identity + span_parent_id = getattr(span, "parent", 0) + set_in_carrier( + carrier, self.TRACE_ID_KEY, _format_trace_id(span_context.trace_id, span_context.span_id, span_parent_id, span_context.trace_flags) + ) + + # set span baggage, if any + baggage_entries = baggage.get_all(context=context) + if not baggage_entries: + return + + for key, value in baggage_entries.items(): + baggage_key = 'uberctx-{}'.format(key) + set_in_carrier( + carrier, baggage_key, value + ) + + +def _format_trace_id(trace_id, span_id, parent_span_id, flags): + return '{:032x}:{:016x}:{:016x}:{:02x}'.format(trace_id, span_id, parent_span_id, flags) + + + + From c1eae690ba8ce262d937954ec499aa5a437267aa Mon Sep 17 00:00:00 2001 From: rashmi_ka Date: Mon, 9 Nov 2020 19:06:13 +0530 Subject: [PATCH 2/7] adding extractor and fixing inject method --- .../sdk/trace/propagation/jaeger_format.py | 87 +++++++++++-- .../trace/propagation/test_jaeger_format.py | 120 ++++++++++++++++++ 2 files changed, 194 insertions(+), 13 deletions(-) create mode 100644 opentelemetry-sdk/tests/trace/propagation/test_jaeger_format.py diff --git a/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_format.py b/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_format.py index e96190be985..c06b24db174 100644 --- a/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_format.py +++ b/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_format.py @@ -13,16 +13,18 @@ # limitations under the License. import typing +import urllib.parse import opentelemetry.trace as trace -from opentelemetry.context import Context +from opentelemetry import baggage +from opentelemetry.context import Context, get_current from opentelemetry.trace.propagation.textmap import ( Getter, Setter, TextMapPropagator, TextMapPropagatorT, ) -from opentelemetry import baggage + class JaegerFormat(TextMapPropagator): """Propagator for the Jaeger format. @@ -30,7 +32,49 @@ class JaegerFormat(TextMapPropagator): See: https://www.jaegertracing.io/docs/1.19/client-libraries/#propagation-format """ - TRACE_ID_KEY = 'uber-trace-id' + TRACE_ID_KEY = "uber-trace-id" + BAGGAGE_PREFIX = "uberctx-" + + def extract( + self, + getter: Getter[TextMapPropagatorT], + carrier: TextMapPropagatorT, + context: typing.Optional[Context] = None, + ) -> Context: + + if context is None: + context = get_current() + fields = _extract_first_element( + getter.get(carrier, self.TRACE_ID_KEY) + ).split(":") + if len(fields) == 4: + trace_id, span_id, _parent_id, flags = fields + else: + return trace.set_span_in_context(trace.INVALID_SPAN) + span = trace.DefaultSpan( + trace.SpanContext( + trace_id=int(trace_id, 16), + span_id=int(span_id, 16), + is_remote=True, + trace_flags=trace.TraceFlags( + int(flags) & trace.TraceFlags.SAMPLED + ), + ) + ) + baggage_keys = [ + key + for key in getter.keys(carrier) + if key.startswith(self.BAGGAGE_PREFIX) + ] + for key in baggage_keys: + value = _extract_first_element(getter.get(carrier, key)) + context = baggage.set_baggage( + key.replace(self.BAGGAGE_PREFIX, ""), + urllib.parse.unquote_plus(value).strip(), + context=context, + ) + return trace.set_span_in_context(span, context) + def inject( self, set_in_carrier: Setter[TextMapPropagatorT], @@ -38,31 +82,48 @@ def inject( context: typing.Optional[Context] = None, ) -> None: span = trace.get_current_span(context=context) - span_context = span.get_context() + span_context = span.get_span_context() if span_context == trace.INVALID_SPAN_CONTEXT: return + span_parent_id = span.parent.span_id if span.parent else 0 + trace_flags = span_context.trace_flags + # set debug flag to True if sampled flag is set + if trace_flags.sampled: + trace_flags |= 0x02 + # set span identity - span_parent_id = getattr(span, "parent", 0) set_in_carrier( - carrier, self.TRACE_ID_KEY, _format_trace_id(span_context.trace_id, span_context.span_id, span_parent_id, span_context.trace_flags) + carrier, + self.TRACE_ID_KEY, + format_uber_trace_id( + span_context.trace_id, + span_context.span_id, + span_parent_id, + trace_flags, + ), ) # set span baggage, if any baggage_entries = baggage.get_all(context=context) if not baggage_entries: return - for key, value in baggage_entries.items(): - baggage_key = 'uberctx-{}'.format(key) + baggage_key = self.BAGGAGE_PREFIX + key set_in_carrier( - carrier, baggage_key, value + carrier, baggage_key, urllib.parse.quote_plus(str(value)) ) -def _format_trace_id(trace_id, span_id, parent_span_id, flags): - return '{:032x}:{:016x}:{:016x}:{:02x}'.format(trace_id, span_id, parent_span_id, flags) - - +def format_uber_trace_id(trace_id, span_id, parent_span_id, flags): + return "{:032x}:{:016x}:{:016x}:{:02x}".format( + trace_id, span_id, parent_span_id, flags + ) +def _extract_first_element( + items: typing.Iterable[TextMapPropagatorT], +) -> typing.Optional[TextMapPropagatorT]: + if items is None: + return None + return next(iter(items), None) diff --git a/opentelemetry-sdk/tests/trace/propagation/test_jaeger_format.py b/opentelemetry-sdk/tests/trace/propagation/test_jaeger_format.py new file mode 100644 index 00000000000..f610d13c5f8 --- /dev/null +++ b/opentelemetry-sdk/tests/trace/propagation/test_jaeger_format.py @@ -0,0 +1,120 @@ +# Copyright The OpenTelemetry Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import unittest + +import opentelemetry.sdk.trace as trace +import opentelemetry.sdk.trace.propagation.jaeger_format as jaeger_format +import opentelemetry.trace as trace_api +from opentelemetry import baggage +from opentelemetry.trace.propagation.textmap import DictGetter + +FORMAT = jaeger_format.JaegerFormat() + + +carrier_getter = DictGetter() + + +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 + + +class TestJaegerFormat(unittest.TestCase): + @classmethod + 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 = jaeger_format.format_uber_trace_id( + cls.trace_id, cls.span_id, cls.parent_span_id, 1 + ) + + def test_extract_valid_span(self): + old_carrier = {FORMAT.TRACE_ID_KEY: self.serialized_uber_trace_id} + ctx = FORMAT.extract(carrier_getter, old_carrier) + span_context = trace_api.get_current_span(ctx).get_span_context() + self.assertEqual(span_context.trace_id, self.trace_id) + self.assertEqual(span_context.span_id, self.span_id) + + def test_trace_id(self): + old_carrier = {FORMAT.TRACE_ID_KEY: self.serialized_uber_trace_id} + _, new_carrier = get_context_new_carrier(old_carrier) + self.assertEqual( + self.serialized_uber_trace_id.split(":")[0], + new_carrier[FORMAT.TRACE_ID_KEY].split(":")[0], + ) + + def test_parent_span_id(self): + old_carrier = {FORMAT.TRACE_ID_KEY: self.serialized_uber_trace_id} + _, new_carrier = get_context_new_carrier(old_carrier) + span_id = self.serialized_uber_trace_id.split(":")[1] + parent_span_id = new_carrier[FORMAT.TRACE_ID_KEY].split(":")[2] + self.assertEqual(span_id, parent_span_id) + + def test_sampled_flag(self): + old_carrier = {FORMAT.TRACE_ID_KEY: self.serialized_uber_trace_id} + _, new_carrier = get_context_new_carrier(old_carrier) + sample_flag_value = ( + int(new_carrier[FORMAT.TRACE_ID_KEY].split(":")[3]) & 0x01 + ) + self.assertEqual(1, sample_flag_value) + + def test_baggage(self): + old_carrier = {FORMAT.TRACE_ID_KEY: self.serialized_uber_trace_id} + input_baggage = {"key1": "value1"} + _, new_carrier = get_context_new_carrier(old_carrier, input_baggage) + ctx = FORMAT.extract(carrier_getter, new_carrier) + self.assertDictEqual(input_baggage, ctx["baggage"]) + + def test_non_string_baggage(self): + old_carrier = {FORMAT.TRACE_ID_KEY: self.serialized_uber_trace_id} + input_baggage = {"key1": 1, "key2": True} + formatted_baggage = {"key1": "1", "key2": "True"} + _, new_carrier = get_context_new_carrier(old_carrier, input_baggage) + ctx = FORMAT.extract(carrier_getter, new_carrier) + self.assertDictEqual(formatted_baggage, ctx["baggage"]) + + def test_extract_invalid_uber_trace_id(self): + carrier = { + "uber-trace-id": "000000000000000000000000deadbeef:00000000deadbef0:00" + } + context = FORMAT.extract(carrier_getter, carrier) + span_context = trace_api.get_current_span(context).get_span_context() + self.assertEqual(span_context.span_id, trace_api.INVALID_SPAN_ID) From a64f5c32e5459736e5d7e19529aa43427a28e760 Mon Sep 17 00:00:00 2001 From: rashmi_ka Date: Sun, 22 Nov 2020 21:20:20 +0530 Subject: [PATCH 3/7] resolving issues --- ...{jaeger_format.py => jaeger_propagator.py} | 53 +++++++++++-------- ...er_format.py => test_jaeger_propagator.py} | 39 +++++++++++--- 2 files changed, 64 insertions(+), 28 deletions(-) rename opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/{jaeger_format.py => jaeger_propagator.py} (81%) rename opentelemetry-sdk/tests/trace/propagation/{test_jaeger_format.py => test_jaeger_propagator.py} (74%) diff --git a/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_format.py b/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_propagator.py similarity index 81% rename from opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_format.py rename to opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_propagator.py index c06b24db174..0f3f0f1fdfd 100644 --- a/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_format.py +++ b/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_propagator.py @@ -26,7 +26,7 @@ ) -class JaegerFormat(TextMapPropagator): +class JaegerPropagator(TextMapPropagator): """Propagator for the Jaeger format. See: https://www.jaegertracing.io/docs/1.19/client-libraries/#propagation-format @@ -47,32 +47,28 @@ def extract( fields = _extract_first_element( getter.get(carrier, self.TRACE_ID_KEY) ).split(":") - if len(fields) == 4: - trace_id, span_id, _parent_id, flags = fields - else: - return trace.set_span_in_context(trace.INVALID_SPAN) + + context = self._extract_baggage(getter, carrier, context) + if len(fields) != 4: + return trace.set_span_in_context(trace.INVALID_SPAN, context) + + trace_id, span_id, _parent_id, flags = fields + if ( + trace_id == trace.INVALID_TRACE_ID + or span_id == trace.INVALID_SPAN_ID + ): + return trace.set_span_in_context(trace.INVALID_SPAN, context) + span = trace.DefaultSpan( trace.SpanContext( trace_id=int(trace_id, 16), span_id=int(span_id, 16), is_remote=True, trace_flags=trace.TraceFlags( - int(flags) & trace.TraceFlags.SAMPLED + int(flags, 16) & trace.TraceFlags.SAMPLED ), ) ) - baggage_keys = [ - key - for key in getter.keys(carrier) - if key.startswith(self.BAGGAGE_PREFIX) - ] - for key in baggage_keys: - value = _extract_first_element(getter.get(carrier, key)) - context = baggage.set_baggage( - key.replace(self.BAGGAGE_PREFIX, ""), - urllib.parse.unquote_plus(value).strip(), - context=context, - ) return trace.set_span_in_context(span, context) def inject( @@ -96,7 +92,7 @@ def inject( set_in_carrier( carrier, self.TRACE_ID_KEY, - format_uber_trace_id( + _format_uber_trace_id( span_context.trace_id, span_context.span_id, span_parent_id, @@ -111,11 +107,26 @@ def inject( for key, value in baggage_entries.items(): baggage_key = self.BAGGAGE_PREFIX + key set_in_carrier( - carrier, baggage_key, urllib.parse.quote_plus(str(value)) + carrier, baggage_key, urllib.parse.quote(str(value)) + ) + + def _extract_baggage(self, getter, carrier, context): + baggage_keys = [ + key + for key in getter.keys(carrier) + if key.startswith(self.BAGGAGE_PREFIX) + ] + for key in baggage_keys: + value = _extract_first_element(getter.get(carrier, key)) + context = baggage.set_baggage( + key.replace(self.BAGGAGE_PREFIX, ""), + urllib.parse.unquote(value).strip(), + context=context, ) + return context -def format_uber_trace_id(trace_id, span_id, parent_span_id, flags): +def _format_uber_trace_id(trace_id, span_id, parent_span_id, flags): return "{:032x}:{:016x}:{:016x}:{:02x}".format( trace_id, span_id, parent_span_id, flags ) diff --git a/opentelemetry-sdk/tests/trace/propagation/test_jaeger_format.py b/opentelemetry-sdk/tests/trace/propagation/test_jaeger_propagator.py similarity index 74% rename from opentelemetry-sdk/tests/trace/propagation/test_jaeger_format.py rename to opentelemetry-sdk/tests/trace/propagation/test_jaeger_propagator.py index f610d13c5f8..d59bda448a4 100644 --- a/opentelemetry-sdk/tests/trace/propagation/test_jaeger_format.py +++ b/opentelemetry-sdk/tests/trace/propagation/test_jaeger_propagator.py @@ -15,12 +15,12 @@ import unittest import opentelemetry.sdk.trace as trace -import opentelemetry.sdk.trace.propagation.jaeger_format as jaeger_format +import opentelemetry.sdk.trace.propagation.jaeger_propagator as jaeger import opentelemetry.trace as trace_api from opentelemetry import baggage from opentelemetry.trace.propagation.textmap import DictGetter -FORMAT = jaeger_format.JaegerFormat() +FORMAT = jaeger.JaegerPropagator() carrier_getter = DictGetter() @@ -55,14 +55,14 @@ def get_context_new_carrier(old_carrier, carrier_baggage=None): return ctx, new_carrier -class TestJaegerFormat(unittest.TestCase): +class TestJaegerPropagator(unittest.TestCase): @classmethod 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 = jaeger_format.format_uber_trace_id( + cls.serialized_uber_trace_id = "{:032x}:{:016x}:{:016x}:{:02x}".format( cls.trace_id, cls.span_id, cls.parent_span_id, 1 ) @@ -112,9 +112,34 @@ def test_non_string_baggage(self): self.assertDictEqual(formatted_baggage, ctx["baggage"]) def test_extract_invalid_uber_trace_id(self): - carrier = { - "uber-trace-id": "000000000000000000000000deadbeef:00000000deadbef0:00" + old_carrier = { + "uber-trace-id": "000000000000000000000000deadbeef:00000000deadbef0:00", + "uberctx-key1": "value1", } - context = FORMAT.extract(carrier_getter, carrier) + formatted_baggage = {"key1": "value1"} + context = FORMAT.extract(carrier_getter, old_carrier) span_context = trace_api.get_current_span(context).get_span_context() self.assertEqual(span_context.span_id, trace_api.INVALID_SPAN_ID) + self.assertDictEqual(formatted_baggage, context["baggage"]) + + def test_extract_invalid_trace_id(self): + old_carrier = { + "uber-trace-id": "00000000000000000000000000000000:00000000deadbef0:00:00", + "uberctx-key1": "value1", + } + formatted_baggage = {"key1": "value1"} + context = FORMAT.extract(carrier_getter, old_carrier) + span_context = trace_api.get_current_span(context).get_span_context() + self.assertEqual(span_context.trace_id, trace_api.INVALID_TRACE_ID) + self.assertDictEqual(formatted_baggage, context["baggage"]) + + def test_extract_invalid_span_id(self): + old_carrier = { + "uber-trace-id": "000000000000000000000000deadbeef:0000000000000000:00:00", + "uberctx-key1": "value1", + } + formatted_baggage = {"key1": "value1"} + context = FORMAT.extract(carrier_getter, old_carrier) + span_context = trace_api.get_current_span(context).get_span_context() + self.assertEqual(span_context.span_id, trace_api.INVALID_SPAN_ID) + self.assertDictEqual(formatted_baggage, context["baggage"]) From a7286ab8c598010a0007705b556812d092e444ee Mon Sep 17 00:00:00 2001 From: rashmi_ka Date: Sun, 22 Nov 2020 21:24:44 +0530 Subject: [PATCH 4/7] Updated CHANGELOG --- opentelemetry-sdk/CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/opentelemetry-sdk/CHANGELOG.md b/opentelemetry-sdk/CHANGELOG.md index 851073bcd51..8fe658eec4d 100644 --- a/opentelemetry-sdk/CHANGELOG.md +++ b/opentelemetry-sdk/CHANGELOG.md @@ -12,6 +12,8 @@ ([#1373](https://github.com/open-telemetry/opentelemetry-python/pull/1373)) - Rename Meter class to Accumulator in Metrics SDK ([#1372](https://github.com/open-telemetry/opentelemetry-python/pull/1372)) +- Added support for Jaeger propagator + ([#1219](https://github.com/open-telemetry/opentelemetry-python/pull/1219)) ## Version 0.15b0 From c8681f78c509456d04524f03140dc64d915b5a58 Mon Sep 17 00:00:00 2001 From: rashmi_ka Date: Wed, 25 Nov 2020 15:33:12 +0530 Subject: [PATCH 5/7] fix linting error --- .../opentelemetry/sdk/trace/propagation/jaeger_propagator.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_propagator.py b/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_propagator.py index 3c9c4ce431d..90eb8120906 100644 --- a/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_propagator.py +++ b/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_propagator.py @@ -18,6 +18,7 @@ import opentelemetry.trace as trace from opentelemetry import baggage from opentelemetry.context import Context, get_current +from opentelemetry.sdk.trace.propagation import extract_first_element from opentelemetry.trace.propagation.textmap import ( Getter, Setter, @@ -25,8 +26,6 @@ TextMapPropagatorT, ) -from . import extract_first_element - class JaegerPropagator(TextMapPropagator): """Propagator for the Jaeger format. From 8bc39ba3469e1b24d9d83298394ccd2f45367dd2 Mon Sep 17 00:00:00 2001 From: rashmi_ka Date: Sun, 6 Dec 2020 16:59:27 +0530 Subject: [PATCH 6/7] Adding fields method in Jaeger propagator --- .../sdk/trace/propagation/jaeger_propagator.py | 6 ++++++ .../trace/propagation/test_jaeger_propagator.py | 13 ++++++++++++- 2 files changed, 18 insertions(+), 1 deletion(-) diff --git a/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_propagator.py b/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_propagator.py index 90eb8120906..7d41138ed5d 100644 --- a/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_propagator.py +++ b/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_propagator.py @@ -111,6 +111,12 @@ def inject( carrier, baggage_key, urllib.parse.quote(str(value)) ) + @property + def fields(self) -> typing.Set[str]: + return { + self.TRACE_ID_KEY + } + def _extract_baggage(self, getter, carrier, context): baggage_keys = [ key diff --git a/opentelemetry-sdk/tests/trace/propagation/test_jaeger_propagator.py b/opentelemetry-sdk/tests/trace/propagation/test_jaeger_propagator.py index 7991f5dd751..11862f6b221 100644 --- a/opentelemetry-sdk/tests/trace/propagation/test_jaeger_propagator.py +++ b/opentelemetry-sdk/tests/trace/propagation/test_jaeger_propagator.py @@ -13,12 +13,12 @@ # limitations under the License. import unittest - import opentelemetry.sdk.trace as trace import opentelemetry.sdk.trace.propagation.jaeger_propagator as jaeger import opentelemetry.trace as trace_api from opentelemetry import baggage from opentelemetry.trace.propagation.textmap import DictGetter +from unittest.mock import Mock FORMAT = jaeger.JaegerPropagator() @@ -170,3 +170,14 @@ def test_extract_invalid_span_id(self): span_context = trace_api.get_current_span(context).get_span_context() self.assertEqual(span_context.span_id, trace_api.INVALID_SPAN_ID) self.assertDictEqual(formatted_baggage, context["baggage"]) + + def test_fields(self): + tracer = trace.TracerProvider().get_tracer("sdk_tracer_provider") + mock_set_in_carrier = Mock() + with tracer.start_as_current_span("parent"): + with tracer.start_as_current_span("child"): + FORMAT.inject(mock_set_in_carrier, {}) + inject_fields = set() + for call in mock_set_in_carrier.mock_calls: + inject_fields.add(call[1][1]) + self.assertEqual(FORMAT.fields, inject_fields) From 2da920abfac6851c6045135ebc0aff0bb51f0420 Mon Sep 17 00:00:00 2001 From: rashmi_ka Date: Sun, 6 Dec 2020 17:06:59 +0530 Subject: [PATCH 7/7] fixing linting error --- .../opentelemetry/sdk/trace/propagation/jaeger_propagator.py | 4 +--- .../tests/trace/propagation/test_jaeger_propagator.py | 3 ++- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_propagator.py b/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_propagator.py index 7d41138ed5d..e4d2b1cb2cc 100644 --- a/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_propagator.py +++ b/opentelemetry-sdk/src/opentelemetry/sdk/trace/propagation/jaeger_propagator.py @@ -113,9 +113,7 @@ def inject( @property def fields(self) -> typing.Set[str]: - return { - self.TRACE_ID_KEY - } + return {self.TRACE_ID_KEY} def _extract_baggage(self, getter, carrier, context): baggage_keys = [ diff --git a/opentelemetry-sdk/tests/trace/propagation/test_jaeger_propagator.py b/opentelemetry-sdk/tests/trace/propagation/test_jaeger_propagator.py index 11862f6b221..bd80770368b 100644 --- a/opentelemetry-sdk/tests/trace/propagation/test_jaeger_propagator.py +++ b/opentelemetry-sdk/tests/trace/propagation/test_jaeger_propagator.py @@ -13,12 +13,13 @@ # limitations under the License. import unittest +from unittest.mock import Mock + import opentelemetry.sdk.trace as trace import opentelemetry.sdk.trace.propagation.jaeger_propagator as jaeger import opentelemetry.trace as trace_api from opentelemetry import baggage from opentelemetry.trace.propagation.textmap import DictGetter -from unittest.mock import Mock FORMAT = jaeger.JaegerPropagator()