From 7327b8021f0f7cc84823bb85f4b4240d29e20638 Mon Sep 17 00:00:00 2001 From: Divya Sharma Date: Tue, 7 Sep 2021 13:38:55 -0700 Subject: [PATCH 1/6] chore(propagator): add opentelemetry-propagator-env --- .../opentelemetry-propagator-env/LICENSE | 201 +++++ .../opentelemetry-propagator-env/MANIFEST.in | 9 + .../opentelemetry-propagator-env/README.rst | 9 + .../opentelemetry-propagator-env/setup.cfg | 54 ++ .../opentelemetry-propagator-env/setup.py | 26 + .../opentelemetry/propagators/env/__init__.py | 2 + .../propagators/env/composite_propagator.py | 75 ++ .../propagators/env/propagator.py | 66 ++ .../opentelemetry/propagators/env/py.typed | 0 .../opentelemetry/propagators/env/version.py | 15 + .../tests/__init__.py | 0 ...format_baggage_composite_env_propagator.py | 591 +++++++++++++ .../test_b3_multi_format_env_propagator.py | 333 ++++++++ ...t_tracecontext_composite_env_propagator.py | 787 ++++++++++++++++++ .../tests/test_b3_single_env_propagator.py | 309 +++++++ ...format_baggage_composite_env_propagator.py | 445 ++++++++++ ..._single_format_composite_env_propagator.py | 347 ++++++++ ...t_tracecontext_composite_env_propagator.py | 586 +++++++++++++ ...ontext_baggage_composite_env_propagator.py | 477 +++++++++++ ...t_tracecontext_composite_env_propagator.py | 189 +++++ .../tests/test_tracecontext_env_propagator.py | 211 +++++ .../tests/utils.py | 121 +++ 22 files changed, 4853 insertions(+) create mode 100644 propagator/opentelemetry-propagator-env/LICENSE create mode 100644 propagator/opentelemetry-propagator-env/MANIFEST.in create mode 100644 propagator/opentelemetry-propagator-env/README.rst create mode 100644 propagator/opentelemetry-propagator-env/setup.cfg create mode 100644 propagator/opentelemetry-propagator-env/setup.py create mode 100644 propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/__init__.py create mode 100644 propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/composite_propagator.py create mode 100644 propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/propagator.py create mode 100644 propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/py.typed create mode 100644 propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/version.py create mode 100644 propagator/opentelemetry-propagator-env/tests/__init__.py create mode 100644 propagator/opentelemetry-propagator-env/tests/test_b3_multi_format_baggage_composite_env_propagator.py create mode 100644 propagator/opentelemetry-propagator-env/tests/test_b3_multi_format_env_propagator.py create mode 100644 propagator/opentelemetry-propagator-env/tests/test_b3_multi_format_tracecontext_composite_env_propagator.py create mode 100644 propagator/opentelemetry-propagator-env/tests/test_b3_single_env_propagator.py create mode 100644 propagator/opentelemetry-propagator-env/tests/test_b3_single_format_baggage_composite_env_propagator.py create mode 100644 propagator/opentelemetry-propagator-env/tests/test_b3_single_format_composite_env_propagator.py create mode 100644 propagator/opentelemetry-propagator-env/tests/test_b3_single_format_tracecontext_composite_env_propagator.py create mode 100644 propagator/opentelemetry-propagator-env/tests/test_tracecontext_baggage_composite_env_propagator.py create mode 100644 propagator/opentelemetry-propagator-env/tests/test_tracecontext_composite_env_propagator.py create mode 100644 propagator/opentelemetry-propagator-env/tests/test_tracecontext_env_propagator.py create mode 100644 propagator/opentelemetry-propagator-env/tests/utils.py diff --git a/propagator/opentelemetry-propagator-env/LICENSE b/propagator/opentelemetry-propagator-env/LICENSE new file mode 100644 index 00000000000..1ef7dad2c5c --- /dev/null +++ b/propagator/opentelemetry-propagator-env/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + 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. diff --git a/propagator/opentelemetry-propagator-env/MANIFEST.in b/propagator/opentelemetry-propagator-env/MANIFEST.in new file mode 100644 index 00000000000..aed3e33273b --- /dev/null +++ b/propagator/opentelemetry-propagator-env/MANIFEST.in @@ -0,0 +1,9 @@ +graft src +graft tests +global-exclude *.pyc +global-exclude *.pyo +global-exclude __pycache__/* +include CHANGELOG.md +include MANIFEST.in +include README.rst +include LICENSE diff --git a/propagator/opentelemetry-propagator-env/README.rst b/propagator/opentelemetry-propagator-env/README.rst new file mode 100644 index 00000000000..1e80b566b2f --- /dev/null +++ b/propagator/opentelemetry-propagator-env/README.rst @@ -0,0 +1,9 @@ +OpenTelemetry Env Propagator +=========================== + +This library provides a propagator to propagate trace/baggage details in a particular format (b3/w3c/any other) +from one process (invoking process) to the next (invoked process) using environment dictionary as the carrier. + +Using environment dictionary as the carrier will help to connect batch processes. +For example: The environment dictionary containing trace/baggage details can be passed to the next process +in the subprocess call. diff --git a/propagator/opentelemetry-propagator-env/setup.cfg b/propagator/opentelemetry-propagator-env/setup.cfg new file mode 100644 index 00000000000..813bd61927e --- /dev/null +++ b/propagator/opentelemetry-propagator-env/setup.cfg @@ -0,0 +1,54 @@ +# 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. +# +[metadata] +name = opentelemetry-propagator-env +description = OpenTelemetry Env Propagator +long_description = file: README.rst +long_description_content_type = text/x-rst +author = Divya Sharma +author_email = divya.sharma22@aexp.com +url = https://github.com/open-telemetry/opentelemetry-python/tree/main/propagator/opentelemetry-propagator-env +platforms = any +license = Apache-2.0 +classifiers = + Development Status :: 5 - Production/Stable + Intended Audience :: Developers + License :: OSI Approved :: Apache Software License + Programming Language :: Python + Programming Language :: Python :: 3 + Programming Language :: Python :: 3.6 + Programming Language :: Python :: 3.7 + Programming Language :: Python :: 3.8 + Programming Language :: Python :: 3.9 + Typing :: Typed + +[options] +python_requires = >=3.6 +package_dir= + =src +packages=find_namespace: +install_requires = + opentelemetry-api ~= 1.3 + +[options.extras_require] +test = + +[options.packages.find] +where = src + +[options.entry_points] +opentelemetry_propagator = + env = opentelemetry.propagators.env.propagator:EnvPropagator + env_composite = opentelemetry.propagators.env.composite_propagator:CompositeEnvPropagator diff --git a/propagator/opentelemetry-propagator-env/setup.py b/propagator/opentelemetry-propagator-env/setup.py new file mode 100644 index 00000000000..fbd34554e91 --- /dev/null +++ b/propagator/opentelemetry-propagator-env/setup.py @@ -0,0 +1,26 @@ +# 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 os + +import setuptools + +BASE_DIR = os.path.dirname(__file__) +VERSION_FILENAME = os.path.join( + BASE_DIR, "src", "opentelemetry", "propagators", "env", "version.py" +) +PACKAGE_INFO = {} +with open(VERSION_FILENAME) as f: + exec(f.read(), PACKAGE_INFO) + +setuptools.setup(version=PACKAGE_INFO["__version__"]) diff --git a/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/__init__.py b/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/__init__.py new file mode 100644 index 00000000000..e0e545e1953 --- /dev/null +++ b/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/__init__.py @@ -0,0 +1,2 @@ +from opentelemetry.propagators.env.propagator import EnvPropagator +from opentelemetry.propagators.env.composite_propagator import CompositeEnvPropagator diff --git a/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/composite_propagator.py b/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/composite_propagator.py new file mode 100644 index 00000000000..8eb1030ddab --- /dev/null +++ b/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/composite_propagator.py @@ -0,0 +1,75 @@ +# 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 os +import typing + +import opentelemetry +from opentelemetry.context.context import Context +from opentelemetry.propagators.b3 import (B3SingleFormat, B3MultiFormat) +from opentelemetry.baggage.propagation import W3CBaggagePropagator +from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator +from opentelemetry.propagators import textmap +from opentelemetry.propagators.textmap import ( + DefaultGetter, + DefaultSetter, + Getter, + Setter, + TextMapPropagator, + CarrierT, + CarrierValT +) + +class CompositeEnvPropagator(TextMapPropagator): + def __init__(self, propagators : typing.Sequence[TextMapPropagator]): + self._propagators = propagators + + def extract(self, carrier: CarrierT, context: typing.Optional[Context] = None, getter: Getter = DefaultGetter()) -> Context: + if not self._propagators: + self._propagators = [TraceContextTextMapPropagator(), W3CBaggagePropagator()] + + for propagator in self._propagators: + if isinstance(propagator, B3SingleFormat): + context = B3MultiFormat().extract(carrier, context, getter) + else: + context = propagator.extract(carrier, context, getter) + return context + + def inject(self, carrier: CarrierT, context: typing.Optional[Context] = None, setter: Setter = textmap.default_setter) -> None: + if not self._propagators: + self._propagators = [TraceContextTextMapPropagator(), W3CBaggagePropagator()] + + for propagator in self._propagators: + propagator.inject(carrier, context, setter) + + # function for the user to inject trace details or baggage + def inject_to_carrier(self, context: typing.Optional[Context] = None): + env_dict = os.environ.copy() + self.inject(carrier=env_dict, context = context, setter = textmap.default_setter) + return env_dict + + # function for the user to extract context + def extract_context(self) -> Context: + return self.extract(carrier=os.environ, getter = DefaultGetter()) + + @property + def fields(self) -> typing.Set[str]: + # Returns a set with the fields set in `inject`. + composite_fields = set() + + for propagator in self._propagators: + for field in propagator.fields: + composite_fields.add(field) + + return composite_fields diff --git a/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/propagator.py b/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/propagator.py new file mode 100644 index 00000000000..08ae4765833 --- /dev/null +++ b/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/propagator.py @@ -0,0 +1,66 @@ +# 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 os +import typing +import logging + +from opentelemetry.context import Context +from opentelemetry.propagators.b3 import (B3SingleFormat, B3MultiFormat) +from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator +from opentelemetry.context.context import Context +from opentelemetry.propagators.textmap import ( + DefaultGetter, + DefaultSetter, + Getter, + Setter, + TextMapPropagator, + CarrierT, + CarrierValT +) + +class EnvPropagator(TextMapPropagator): + def __init__(self, formatter): + self.formatter = formatter + + # delegating to extract function implementation of the formatter + def extract(self, carrier: CarrierT, context: typing.Optional[Context] = None, getter: Getter = DefaultGetter()) -> Context: + if isinstance(self.formatter, B3SingleFormat): + return B3MultiFormat().extract(carrier = carrier, context=context, getter = getter) + return self.formatter.extract(carrier = carrier, context=context, getter = getter) + + # delegating to inject function implementation of the formatter + def inject(self, carrier: CarrierT, context: typing.Optional[Context] = None, setter: Setter = DefaultSetter()) -> None: + self.formatter.inject(carrier = carrier, context = context, setter = setter) + + # function for the user to inject trace details or baggage + def inject_to_carrier(self, context: typing.Optional[Context] = None): + if self.formatter is None: + self.formatter = TraceContextTextMapPropagator() + + env_dict = os.environ.copy() + self.inject(carrier=env_dict, context = context, setter=DefaultSetter()) + return env_dict + + # function for the user to extract trace context or baggage + def extract_context(self) -> Context: + if self.formatter is None: + self.formatter = TraceContextTextMapPropagator() + + return self.extract(carrier=os.environ, getter=DefaultGetter()) + + @property + def fields(self) -> typing.Set[str]: + # Returns a set with the fields set in `inject`. + return self.formatter.fields diff --git a/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/py.typed b/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/py.typed new file mode 100644 index 00000000000..e69de29bb2d diff --git a/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/version.py b/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/version.py new file mode 100644 index 00000000000..c8902adc49b --- /dev/null +++ b/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/version.py @@ -0,0 +1,15 @@ +# 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. + +__version__ = "1.5.0" diff --git a/propagator/opentelemetry-propagator-env/tests/__init__.py b/propagator/opentelemetry-propagator-env/tests/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/propagator/opentelemetry-propagator-env/tests/test_b3_multi_format_baggage_composite_env_propagator.py b/propagator/opentelemetry-propagator-env/tests/test_b3_multi_format_baggage_composite_env_propagator.py new file mode 100644 index 00000000000..dbf9e2f3b3c --- /dev/null +++ b/propagator/opentelemetry-propagator-env/tests/test_b3_multi_format_baggage_composite_env_propagator.py @@ -0,0 +1,591 @@ +# 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 os +import unittest +from unittest import mock + +import opentelemetry +from opentelemetry import baggage +from opentelemetry.propagators.b3 import B3MultiFormat +from opentelemetry.propagators.env.composite_propagator import CompositeEnvPropagator +from opentelemetry.propagators.textmap import DefaultGetter, DefaultSetter +from opentelemetry.trace.propagation import tracecontext +from opentelemetry.baggage.propagation import W3CBaggagePropagator +from tests.utils import * + +getter = DefaultGetter() +class TestB3MultiBaggageCompositeEnvPropagator(unittest.TestCase): + def setUp(self): + self.mock_carrier = {} + self.composite_propagator_b3_baggage_object = CompositeEnvPropagator([B3MultiFormat(), W3CBaggagePropagator()]) + self.composite_propagator_None_object = CompositeEnvPropagator(None) + + # Test cases for inject_to_carrier + + def test_inject_to_carrier_when_valid_context_attached(self): + valid_dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(valid_dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(valid_dummy_context) + self.mock_carrier = self.composite_propagator_b3_baggage_object.inject_to_carrier() + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + opentelemetry.context.detach(token) + + def test_inject_to_carrier_when_invalid_context_attached(self): + invalid_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(invalid_context) + self.mock_carrier = self.composite_propagator_b3_baggage_object.inject_to_carrier() + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + opentelemetry.context.detach(token) + + def test_inject_to_carrier_when_valid_context_with_baggage_passed_as_param(self): + valid_dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(valid_dummy_context) + self.mock_carrier = self.composite_propagator_b3_baggage_object.inject_to_carrier(context = valid_dummy_context) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_valid_context_with_parent_span_and_no_baggage_passed_as_param(self): + valid_dummy_context = create_dummy_context_with_parent_span() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(valid_dummy_context) + self.mock_carrier = self.composite_propagator_b3_baggage_object.inject_to_carrier(context = valid_dummy_context) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertEqual(self.mock_carrier.get("x-b3-parentspanid") , str(parentspanid)) + self.assertIsNotNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("baggage") ) + self.assertIsNone(self.mock_carrier.get("b3")) + + + def test_inject_to_carrier_when_invalid_context_with_baggage_passed_as_param(self): + invalid_dummy_context = create_invalid_context_with_baggage() + self.mock_carrier = self.composite_propagator_b3_baggage_object.inject_to_carrier(context = invalid_dummy_context) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + + + def test_inject_to_carrier_when_attached_context_and_context_passed_as_param_are_different(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_valid_context_with_baggage2() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(context_passed) + self.mock_carrier = self.composite_propagator_b3_baggage_object.inject_to_carrier(context_passed) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid2)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid2)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled2)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertNotEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertNotEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("baggage") , "key3=1,key4=2") + self.assertNotEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + + # Test cases for inject + + ## Test cases for inject when None object is passed to the propagator + + def test_inject_with_None_object_and_when_valid_context_with_baggage_attached(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_propagator_None_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + opentelemetry.context.detach(token) + + def test_inject_with_None_object_and_when_invalid_context_with_baggage_attached(self): + dummy_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_propagator_None_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + opentelemetry.context.detach(token) + + def test_inject_with_None_object_and_when_valid_context_with_baggage_passed_as_param(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_propagator_None_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_with_None_object_and_when_invalid_context_with_baggage_passed_as_param(self): + dummy_context = create_invalid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_propagator_None_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_with_None_object_and_when_valid_context_attached_and_None_context_passed_as_param(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_propagator_None_object.inject(carrier = self.mock_carrier, context = None, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + opentelemetry.context.detach(token) + + def test_inject_with_None_object_and_when_valid_context_with_no_baggage_attached(self): + dummy_context = create_dummy_context_with_parent_span() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_propagator_None_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + opentelemetry.context.detach(token) + + ## other test cases for inject + + def test_inject_when_valid_context_with_no_baggage_attached(self): + dummy_context = create_dummy_context_with_parent_span() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertEqual(self.mock_carrier.get("x-b3-parentspanid") , str(parentspanid)) + opentelemetry.context.detach(token) + + def test_inject_when_invalid_context_with_no_baggage_attached(self): + invalid_dummy_context = create_invalid_context() + token = opentelemetry.context.attach(invalid_dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(invalid_dummy_context) + self.composite_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + opentelemetry.context.detach(token) + + def test_inject_when_valid_context_with_baggage_attached(self): + valid_dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(valid_dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(valid_dummy_context) + self.composite_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + opentelemetry.context.detach(token) + + def test_inject_when_invalid_context_with_baggage_attached(self): + dummy_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid") ) + self.assertIsNone(self.mock_carrier.get("b3")) + opentelemetry.context.detach(token) + + def test_inject_when_valid_context_with_parent_span_and_no_baggage_passed_as_param(self): + dummy_context = create_dummy_context_with_parent_span() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertEqual(self.mock_carrier.get("x-b3-parentspanid") , str(parentspanid)) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_invalid_context_with_no_baggage_passed_as_param(self): + dummy_context = create_invalid_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_valid_context_with_baggage_passed_as_param(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_invalid_context_with_baggage_passed_as_param(self): + dummy_context = create_invalid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_context_with_baggage_attached_and_context_with_baggage_passed_as_param_are_different(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_valid_context_with_baggage2() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(context_passed) + self.composite_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, context = context_passed, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid2)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid2)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled2)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertEqual(self.mock_carrier.get("baggage") , "key3=1,key4=2") + opentelemetry.context.detach(token) + + def test_inject_when_context_attached_and_context_with_no_baggage_passed_as_param_are_different(self): + dummy_context = create_dummy_context() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_dummy_context2() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(context_passed) + self.composite_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, context = context_passed, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid2)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid2)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled2)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertIsNone(self.mock_carrier.get("baggage")) + opentelemetry.context.detach(token) + + def test_inject_when_valid_context_with_no_baggage_passed_as_param(self): + dummy_context = create_dummy_context_with_parent_span() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertEqual(self.mock_carrier.get("x-b3-parentspanid") , str(parentspanid)) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_traceid_has_16_hex_char(self): + dummy_context = create_dummy_context3() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + + + ## Test cases for extract + + def test_extract_when_no_trace_details(self): + extracted_context = self.composite_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,=value2"}) + def test_extract_when_b3_and_baggage_are_valid(self): + extracted_context = self.composite_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertEqual(val1 , "value1") + self.assertIsNone(val2) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "/value1"}) + def test_extract_when_b3_format_is_valid_and_baggage_invalid(self): + extracted_context = self.composite_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val = baggage.get_all(extracted_context) + self.assertEqual(val , {}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,key2=value2"}) + def test_extract_when_baggage_is_valid_but_b3_spanid_is_invalid(self): + extracted_context = self.composite_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) + print("****extracted_context: ***", extracted_context) + self.assertEqual(baggage.get_all(extracted_context), {'key1':'value1', 'key2':'value2'}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,key2=value2"}) + def test_extract_when_baggage_is_valid_and_traceid_of_b3_has_16_hex_char(self): + extracted_context = self.composite_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '000000000000000098fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertEqual(val1 , "value1") + self.assertEqual(val2 , "value2") + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c5"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de-136eec09c948be26-01"}) + def test_extract_when_b3_traceid_is_invalid(self): + extracted_context = self.composite_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c5"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de-136eec09c-01"}) + def test_extract_when_b3_traceid_and_spanid_are_invalid(self): + extracted_context = self.composite_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,=value2"}) + def test_extract_when_a_baggage_key_is_not_passed(self): + extracted_context = self.composite_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + self.assertEqual(baggage.get_all(extracted_context) , {'key1':'value1','':'value2'}) + + @mock.patch.dict(os.environ, {"baggage": "example1-value1;example2-value2"}) + def test_extract_baggage_invalid_format(self): + extracted_context = self.composite_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"baggage": "example1=value1%2Cvalue2,example2=value3%2Cvalue4"}) + def test_extract_when_baggage_with_valid_format_has_commas_in_values(self): + extracted_context = self.composite_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) + self.assertEqual(baggage.get_all(extracted_context) , {'example1':'value1,value2', 'example2':'value3,value4'}) + + + # test cases for extract_context + + def test_extract_context_when_no_trace_details(self): + extracted_context = self.composite_propagator_b3_baggage_object.extract_context() + self.assertEqual(extracted_context ,{}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,=value2"}) + def test_extract_context_when_b3_and_baggage_are_valid(self): + extracted_context = self.composite_propagator_b3_baggage_object.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertEqual(val1 , "value1") + self.assertIsNone(val2) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "=value1"}) + def test_extract_context_when_b3_format_is_valid_and_baggage_invalid(self): + extracted_context = self.composite_propagator_b3_baggage_object.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val = baggage.get_all(extracted_context) + self.assertEqual(val , {'': 'value1'}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,key2=value2"}) + def test_extract_context_when_baggage_is_valid_but_b3_spanid_is_invalid(self): + extracted_context = self.composite_propagator_b3_baggage_object.extract_context() + self.assertEqual(baggage.get_all(extracted_context) , {'key1':'value1', 'key2':'value2'}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-000000000000000098fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,key2=value2"}) + def test_extract_context_when_baggage_is_valid_and_traceid_of_b3_has_16_hex_char(self): + extracted_context = self.composite_propagator_b3_baggage_object.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '000000000000000098fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertEqual(val1 , "value1") + self.assertEqual(val2 , "value2") + + @mock.patch.dict(os.environ, {"x-b3-traceid": "98fea"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de56a789da-136eec09c948be27-01"}) + def test_extract_context_when_b3_traceid_is_invalid(self): + extracted_context = self.composite_propagator_b3_baggage_object.extract_context() + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "98fea"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de-136eec09c-01"}) + def test_extract_context_when_b3_traceid_and_spanid_are_invalid(self): + extracted_context = self.composite_propagator_b3_baggage_object.extract_context() + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,=value2"}) + def test_extract_context_when_a_baggage_key_is_not_passed(self): + extracted_context = self.composite_propagator_b3_baggage_object.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + self.assertEqual(baggage.get_all(extracted_context), {'key1':'value1', '':'value2'}) + + @mock.patch.dict(os.environ, {"baggage": "example1-value1;example2-value2"}) + def test_extract_context_baggage_invalid_format(self): + extracted_context = self.composite_propagator_b3_baggage_object.extract_context() + val1 = baggage.get_baggage("example1", extracted_context) + val2 = baggage.get_baggage("example2", extracted_context) + self.assertNotEqual(val1 , "value1") + self.assertNotEqual(val2 , "value2") + self.assertIsNone(val1) + self.assertIsNone(val2) + + @mock.patch.dict(os.environ, {"baggage": "example1=value1%2Cvalue2,example2=value3%2Cvalue4"}) + def test_extract_context_when_baggage_with_valid_format_has_commas_in_values(self): + extracted_context = self.composite_propagator_b3_baggage_object.extract_context() + val1 = baggage.get_baggage("example1", extracted_context) + val2 = baggage.get_baggage("example2", extracted_context) + self.assertEqual(val1 , "value1,value2") + self.assertEqual(val2 , "value3,value4") diff --git a/propagator/opentelemetry-propagator-env/tests/test_b3_multi_format_env_propagator.py b/propagator/opentelemetry-propagator-env/tests/test_b3_multi_format_env_propagator.py new file mode 100644 index 00000000000..46bd99e3268 --- /dev/null +++ b/propagator/opentelemetry-propagator-env/tests/test_b3_multi_format_env_propagator.py @@ -0,0 +1,333 @@ +# 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 os +import re +import unittest +from unittest import mock + +import opentelemetry +from opentelemetry.propagators.b3 import B3MultiFormat +from opentelemetry.propagators.env.propagator import EnvPropagator +from opentelemetry.propagators.textmap import DefaultGetter, DefaultSetter +from tests.utils import * + +getter = DefaultGetter() +class TestB3MultiEnvPropagator(unittest.TestCase): + def setUp(self): + self.mock_carrier = {} + self.env_propagator_b3_obj = EnvPropagator(B3MultiFormat()) + self.env_propagator_None_obj = EnvPropagator(None) + self.b3_object = B3MultiFormat() + + # Test cases for inject_to_carrier + + def test_inject_to_carrier_when_None_object_passed_to_env_propagator(self): + dummy_context = create_dummy_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + env_None = self.env_propagator_None_obj.inject_to_carrier(dummy_context) + self.assertEqual(env_None.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + + + def test_inject_to_carrier_when_None_object_passed_to_env_propagator_and_context_attached(self): + dummy_context = create_dummy_context() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + env_None = self.env_propagator_None_obj.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertEqual(env_None.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + + + def test_inject_to_carrier_when_context_attached_has_valid_span_context(self): + dummy_context = create_dummy_context() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + env_b3 = self.env_propagator_b3_obj.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertEqual(env_b3.get("x-b3-traceid") , str(traceid)) + self.assertEqual(env_b3.get("x-b3-spanid") , str(spanid)) + self.assertIsNone(env_b3.get("x-b3-parentspanid")) + self.assertEqual(env_b3.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(env_b3.get("traceparent")) + self.assertIsNone(env_b3.get("b3")) + + def test_inject_to_carrier_when_context_passed_as_param_is_None(self): + dummy_context = create_dummy_context() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + env_b3 = self.env_propagator_b3_obj.inject_to_carrier(None) + opentelemetry.context.detach(token) + self.assertEqual(env_b3.get("x-b3-traceid") , str(traceid)) + self.assertEqual(env_b3.get("x-b3-spanid") , str(spanid)) + self.assertIsNone(env_b3.get("x-b3-parentspanid")) + self.assertEqual(env_b3.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(env_b3.get("traceparent")) + self.assertIsNone(env_b3.get("b3")) + + def test_inject_to_carrier_when_valid_context_is_passed_as_param(self): + context_passed = create_dummy_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + env_b3 = self.env_propagator_b3_obj.inject_to_carrier(context_passed) + self.assertEqual(env_b3.get("x-b3-traceid") , str(traceid)) + self.assertEqual(env_b3.get("x-b3-spanid") , str(spanid)) + self.assertIsNone(env_b3.get("x-b3-parentspanid")) + self.assertEqual(env_b3.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(env_b3.get("traceparent")) + self.assertIsNone( env_b3.get("b3")) + + + def test_inject_to_carrier_when_context_attached_and_context_passed_as_param_are_different(self): + dummy_context = create_dummy_context2() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_dummy_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(dummy_context) + env_b3 = self.env_propagator_b3_obj.inject_to_carrier(context_passed) + opentelemetry.context.detach(token) + self.assertEqual(env_b3.get("x-b3-traceid") , str(traceid)) + self.assertEqual(env_b3.get("x-b3-spanid") , str(spanid)) + self.assertIsNone(env_b3.get("x-b3-parentspanid")) + self.assertEqual(env_b3.get("x-b3-sampled") , str(sampled)) # sampled and sampled2 are equal to 0 + self.assertNotEqual(env_b3.get("x-b3-traceid") , str(traceid2)) + self.assertNotEqual(env_b3.get("x-b3-spanid") , str(spanid2)) + self.assertIsNone(env_b3.get("x-b3-parentspanid")) + self.assertIsNone(env_b3.get("traceparent")) + self.assertIsNone(env_b3.get("b3")) + + + ## Test cases for extract_context + + def test_extract_context_when_no_trace_details_in_b3_format(self): + extracted_context_b3 = self.env_propagator_b3_obj.extract_context() + self.assertEqual(extracted_context_b3 , {}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + def test_extract_context_when_b3_valid_format(self): + extracted_context = self.env_propagator_b3_obj.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + self.assertEqual(tracestate , {}) + self.assertIsNone(parentspanid) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c5765"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled'": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + def test_extract_context_when_traceid_does_not_match_regex_for_b3_and_parent_span_id_present(self): + extracted_context_b3 = self.env_propagator_b3_obj.extract_context() + self.assertEqual(extracted_context_b3 , {}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c5765"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled'": "1"}) + def test_extract_context_when_traceid_does_not_match_regex_for_b3_and_parent_span_id_not_present(self): + extracted_context_b3 = self.env_propagator_b3_obj.extract_context() + self.assertEqual(extracted_context_b3 , {}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136ee"}) + @mock.patch.dict(os.environ, {"x-b3-sampled'": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + def test_extract_context_when_spanid_does_not_match_regex_for_b3_and_parent_span_id_present(self): + extracted_context_b3 = self.env_propagator_b3_obj.extract_context() + self.assertEqual(extracted_context_b3 , {}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136ee"}) + @mock.patch.dict(os.environ, {"x-b3-sampled'": "1"}) + def test_extract_context_when_spanid_does_not_match_regex_for_b3_and_parent_span_id_not_present(self): + extracted_context_b3 = self.env_propagator_b3_obj.extract_context() + self.assertEqual(extracted_context_b3 , {}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136ee"}) + def test_extract_context_when_traceid_is_valid_and_spanid_does_not_match_regex_for_b3(self): + extracted_context_b3 = self.env_propagator_b3_obj.extract_context() + self.assertEqual(extracted_context_b3 , {}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c5765"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136ee"}) + @mock.patch.dict(os.environ, {"x-b3-sampled'": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + def test_extract_context_when_traceid_and_spanid_do_not_match_regex_for_b3_and_parent_span_id_present(self): + extracted_context_b3 = self.env_propagator_b3_obj.extract_context() + self.assertEqual(extracted_context_b3 , {}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c5765"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136ee"}) + @mock.patch.dict(os.environ, {"x-b3-sampled'": "1"}) + def test_extract_context_when_traceid_and_spanid_do_not_match_regex_for_b3_and_parent_span_id_not_present(self): + extracted_context_b3 = self.env_propagator_b3_obj.extract_context() + self.assertEqual(extracted_context_b3 , {}) + + @mock.patch.dict(os.environ, {"b3'": "8128c5-136ee"}) + def test_extract_context_when_traceid_and_spanid_are_invalid(self): + extracted_context_b3 = self.env_propagator_b3_obj.extract_context() + self.assertEqual(extracted_context_b3 , {}) + + + ## Test cases for inject + + def test_inject_b3format_when_valid_context_is_passed_as_param_and_parent_span_id_is_present(self): + test_context = create_dummy_context_with_parent_span() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + self.env_propagator_b3_obj.inject(carrier = self.mock_carrier, context = test_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(trace_id)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(span_id)) + self.assertEqual(self.mock_carrier.get("x-b3-parentspanid") , str(parent_span_id)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled_flag)) + self.assertIsNone(self.mock_carrier.get("b3")) + + + def test_inject_b3format_when_valid_context_is_passed_as_param_and_parent_span_id_is_not_present(self): + test_context = create_dummy_context() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + self.env_propagator_b3_obj.inject(carrier = self.mock_carrier, context = test_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(trace_id)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(span_id)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled_flag)) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_b3format_when_invalid_context_passed_as_param_and_parent_span_id_not_present(self): + test_context = create_invalid_context() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + self.env_propagator_b3_obj.inject(carrier = self.mock_carrier, context = test_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_b3format_when_valid_context_attached_and_parent_span_id_present(self): + test_context = create_dummy_context_with_parent_span() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + token = opentelemetry.context.attach(test_context) + self.env_propagator_b3_obj.inject(carrier = self.mock_carrier, context = test_context, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(trace_id)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(span_id)) + self.assertEqual(self.mock_carrier.get("x-b3-parentspanid") , str(parent_span_id)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled_flag)) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_b3format_when_invalid_context_attached_and_parent_span_id_not_present(self): + test_context = create_invalid_context() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + token = opentelemetry.context.attach(test_context) + self.env_propagator_b3_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + + def test_inject_b3format_when_valid_context_attached_and_parent_span_id_not_present(self): + test_context = create_dummy_context() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + token = opentelemetry.context.attach(test_context) + self.env_propagator_b3_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(trace_id)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(span_id)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled_flag)) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_context_attached_and_context_passed_as_param_are_different(self): + dummy_context = create_dummy_context2() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_dummy_context_with_parent_span() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(dummy_context) + self.env_propagator_b3_obj.inject(carrier = self.mock_carrier, context = context_passed, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-parentspanid") , str(parentspanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertNotEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid2)) + self.assertNotEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid2)) + self.assertNotEqual(self.mock_carrier.get("x-b3-parentspanid") , (parentspanid2)) # sampled and sampled2 are equal to 0 + self.assertIsNone(self.mock_carrier.get("b3")) + + ## Test cases for b3 extract + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + def test_extract_valid_b3format(self): + extracted_context = self.env_propagator_b3_obj.extract(getter = getter, carrier = os.environ) + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(extracted_context) + self.assertEqual(trace_id , "8128c50fd8653b5d98fea4de58eca772") + self.assertEqual(span_id , "136eec09c948be26") + self.assertEqual(sampled_flag , 1) + self.assertEqual(tracestate , {}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8238c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "177eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + def test_extract_valid_b3format_without_parent_span_id(self): + extracted_context = self.env_propagator_b3_obj.extract(getter = getter, carrier = os.environ) + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(extracted_context) + self.assertEqual(trace_id , "8238c50fd8653b5d98fea4de58eca772") + self.assertEqual(span_id , "177eec09c948be26") + self.assertEqual(sampled_flag , 1) + self.assertEqual(tracestate , {}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c5"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + def test_extract_invalid_b3format(self): + extracted_context = self.env_propagator_b3_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "177eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + def test_extract_16_hex_char_trace_id_and_parent_span_id_present(self): + extracted_context = self.env_propagator_b3_obj.extract(getter = getter, carrier = os.environ) + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(extracted_context) + trace_id_match = re.fullmatch(self.b3_object._trace_id_regex, trace_id) + span_id_match = re.fullmatch(self.b3_object._span_id_regex, span_id) + self.assertNotEqual(trace_id , "8128c50fd8653b5d") + self.assertEqual(trace_id , "00000000000000008128c50fd8653b5d") + self.assertEqual(span_id , "177eec09c948be26") + self.assertEqual(sampled_flag , 1) + self.assertNotEqual(trace_id_match , None) + self.assertNotEqual(span_id_match , None) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "177eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + def test_extract_16_hex_char_trace_id_and_no_parent_span_id_present(self): + extracted_context = self.env_propagator_b3_obj.extract(getter = getter, carrier = os.environ) + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(extracted_context) + trace_id_match = re.fullmatch(self.b3_object._trace_id_regex, trace_id) + span_id_match = re.fullmatch(self.b3_object._span_id_regex, span_id) + self.assertNotEqual(trace_id , "8128c50fd8653b5d") + self.assertEqual(trace_id , "00000000000000008128c50fd8653b5d") + self.assertEqual(span_id , "177eec09c948be26") + self.assertEqual(sampled_flag , 1) + self.assertNotEqual(trace_id_match , None) + self.assertNotEqual(span_id_match , None) diff --git a/propagator/opentelemetry-propagator-env/tests/test_b3_multi_format_tracecontext_composite_env_propagator.py b/propagator/opentelemetry-propagator-env/tests/test_b3_multi_format_tracecontext_composite_env_propagator.py new file mode 100644 index 00000000000..041cadf6dbc --- /dev/null +++ b/propagator/opentelemetry-propagator-env/tests/test_b3_multi_format_tracecontext_composite_env_propagator.py @@ -0,0 +1,787 @@ +# 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 os +import unittest +from unittest import mock + +import opentelemetry +from opentelemetry.propagators.textmap import DefaultGetter, DefaultSetter +from opentelemetry.propagators.b3 import B3MultiFormat +from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator +from opentelemetry.baggage.propagation import W3CBaggagePropagator +from opentelemetry import baggage +from opentelemetry.propagators.env.composite_propagator import CompositeEnvPropagator +from tests.utils import * + +getter = DefaultGetter() +class TestB3MultiTraceContextEnvPropagator(unittest.TestCase): + def setUp(self): + self.mock_carrier = {} + self.composite_env_propagator_b3_w3c_object = CompositeEnvPropagator([B3MultiFormat(), TraceContextTextMapPropagator()]) + self.composite_env_propagator_object = CompositeEnvPropagator([B3MultiFormat(), TraceContextTextMapPropagator(), W3CBaggagePropagator()]) + self.composite_env_propagator_None_object = CompositeEnvPropagator(None) + + # Test cases for inject + + def test_inject_when_None_object_passed_to_the_propagator_and_valid_context_attached(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_None_object_passed_to_the_propagator_and_invalid_context_attached(self): + dummy_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_None_object_passed_to_the_propagator_and_valid_context_passed_as_param(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_None_object_passed_to_the_propagator_and_invalid_context_passed_as_param(self): + dummy_context = create_invalid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_None_object_passed_to_the_propagator_and_None_context_passed_as_param(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_object.inject(carrier = self.mock_carrier, context = None, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_None_object_passed_to_the_propagator_and_valid_context_without_baggage_attached(self): + dummy_context = create_dummy_context_with_parent_span() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + + def test_inject_when_valid_context_without_baggage_attached_for_w3c_and_b3(self): + dummy_context = create_dummy_context_with_parent_span() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_w3c_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertEqual(self.mock_carrier.get("x-b3-parentspanid") , str(parentspanid)) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_invalid_context_without_baggage_attached_for_w3c_and_b3(self): + dummy_context = create_invalid_context() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_w3c_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_valid_context_with_baggage_attached_for_w3c_and_b3(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_w3c_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_invalid_context_with_baggage_attached_for_w3c_and_b3(self): + dummy_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_w3c_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_valid_context_with_no_baggage_passed_as_param_for_w3c_and_b3(self): + dummy_context = create_dummy_context_with_parent_span() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_w3c_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertEqual(self.mock_carrier.get("x-b3-parentspanid") , str(parentspanid)) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_invalid_context_with_no_baggage_passed_as_param_for_w3c_and_b3(self): + dummy_context = create_invalid_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_w3c_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_valid_context_with_baggage_passed_as_param_for_w3c_and_b3(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_w3c_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_invalid_context_with_baggage_passed_as_param_for_w3c_and_b3(self): + dummy_context = create_invalid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_w3c_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_context_with_baggage_attached_and_context_passed_as_param_with_baggage_are_different_for_w3c_and_b3(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_valid_context_with_baggage2() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_w3c_object.inject(carrier = self.mock_carrier, context = context_passed, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertIsNone(self.mock_carrier.get("baggage")) + + def test_inject_when_context_attached_and_context_passed_as_param_without_baggage_are_different_for_w3c_and_b3(self): + dummy_context = create_dummy_context() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_dummy_context2() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_w3c_object.inject(carrier = self.mock_carrier, context = context_passed, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3") ) + self.assertIsNone(self.mock_carrier.get("baggage")) + + def test_inject_when_valid_context_with_baggage_attached_for_all_3_formats(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_valid_context_without_baggage_attached_for_all_3_formats(self): + dummy_context = create_dummy_context_with_parent_span() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertEqual(self.mock_carrier.get("x-b3-parentspanid") , str(parentspanid)) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_invalid_context_with_baggage_attached_for_all_3_formats(self): + current_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(current_context) + self.composite_env_propagator_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_valid_context_with_baggage_passed_for_all_3_formats(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_valid_context_with_no_baggage_passed_for_all_3_formats(self): + dummy_context = create_dummy_context_with_parent_span() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertEqual(self.mock_carrier.get("x-b3-parentspanid") , str(parentspanid)) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_invalid_context_with_baggage_passed_for_all_3_formats(self): + dummy_context = create_invalid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("x-b3-traceid") ) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled") ) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid") ) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_traceid_has_16_hex_char(self): + dummy_context = create_dummy_context3() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + + # Test cases for for inject_to_carrier w3c and b3 formats with/without baggage + + def test_inject_to_carrier_when_valid_context_without_baggage_attached_for_w3c_and_b3(self): + dummy_context = create_dummy_context_with_parent_span() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_object.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertEqual(self.mock_carrier.get("x-b3-parentspanid") , str(parentspanid)) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_invalid_context_without_baggage_attached_for_w3c_and_b3(self): + dummy_context = create_invalid_context() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_object.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_valid_context_with_baggage_attached_for_w3c_and_b3(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_object.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_invalid_context_with_baggage_attached_for_w3c_and_b3(self): + dummy_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_object.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_valid_context_without_baggage_passed_as_param_for_w3c_and_b3(self): + dummy_context = create_dummy_context_with_parent_span() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_object.inject_to_carrier(context = dummy_context) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertEqual(self.mock_carrier.get("x-b3-parentspanid") , str(parentspanid)) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_invalid_context_without_baggage_passed_as_param_for_w3c_and_b3(self): + dummy_context = create_invalid_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_object.inject_to_carrier(context = dummy_context) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_valid_context_with_baggage_passed_as_param_for_w3c_and_b3(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_object.inject_to_carrier(context = dummy_context) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_invalid_context_with_baggage_passed_as_param_for_w3c_and_b3(self): + dummy_context = create_invalid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_object.inject_to_carrier(context = dummy_context) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_context_with_baggage_attached_and_context_passed_as_param_with_baggage_are_different_for_w3c_and_b3(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_valid_context_with_baggage2() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_object.inject_to_carrier(context_passed) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertIsNone(self.mock_carrier.get("baggage")) + + def test_inject_to_carrier_when_context_attached_and_context_passed_without_baggage_are_different_for_w3c_and_b3(self): + dummy_context = create_dummy_context() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_dummy_context2() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_object.inject_to_carrier(context_passed) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertIsNone(self.mock_carrier.get("baggage")) + + def test_inject_to_carrier_when_valid_context_is_attached_for_all_3_formats(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_object.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_valid_context_without_baggage_is_attached_for_all_3_formats(self): + dummy_context = create_dummy_context_with_parent_span() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_object.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertEqual(self.mock_carrier.get("x-b3-parentspanid") , str(parentspanid)) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_invalid_context_is_attached_for_all_3_formats(self): + current_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(current_context) + self.mock_carrier = self.composite_env_propagator_object.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled")) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_valid_context_passed_as_param_for_all_3_formats(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_object.inject_to_carrier(context = dummy_context) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_valid_context_without_baggage_passed_as_param_for_all_3_formats(self): + dummy_context = create_dummy_context_with_parent_span() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_object.inject_to_carrier(context = dummy_context) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertEqual(self.mock_carrier.get("x-b3-parentspanid") , str(parentspanid)) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_invalid_context_passed_as_param_for_all_3_formats(self): + dummy_context = create_invalid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_object.inject_to_carrier(context = dummy_context) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) + self.assertIsNone(self.mock_carrier.get("x-b3-spanid")) + self.assertIsNone(self.mock_carrier.get("x-b3-sampled") ) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_traceid_has_16_hex_char(self): + dummy_context = create_dummy_context3() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_object.inject_to_carrier(context = dummy_context) + self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) + self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) + self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) + self.assertIsNone(self.mock_carrier.get("x-b3-parentspanid")) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + + ## Test cases for extract_context + + def test_extract_context_when_no_trace_details(self): + extracted_context = self.composite_env_propagator_object.extract_context() + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled'": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,=value2"}) + def test_extract_context_when_all_3_formats_are_valid(self): + extracted_context = self.composite_env_propagator_object.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertEqual(val1 , "value1") + self.assertIsNone(val2) + + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled'": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "=value1"}) + def test_extract_context_when_w3c_and_b3_formats_are_valid_and_baggage_invalid(self): + extracted_context = self.composite_env_propagator_object.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val = baggage.get_baggage("key1", extracted_context) + self.assertIsNone(val) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c"}) + @mock.patch.dict(os.environ, {"x-b3-sampled'": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,key2=value2"}) + def test_extract_context_when_baggage_is_valid_but_w3c_and_b3_spanid_are_invalid(self): + extracted_context = self.composite_env_propagator_object.extract_context() + self.assertEqual(baggage.get_all(extracted_context) , {'key1':'value1','key2':'value2'}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + + @mock.patch.dict(os.environ, {"x-b3-traceid": "98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,key2=value2"}) + def test_extract_context_when_baggage_is_valid_and_traceid_of_b3_and_w3c_have_16_hex_char(self): + extracted_context = self.composite_env_propagator_object.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '000000000000000098fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertEqual(val1 , "value1") + self.assertEqual(val2 , "value2") + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50f"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50f-136eec09c948be26-01"}) + def test_extract_context_when_w3c_and_b3_traceid_is_invalid(self): + extracted_context = self.composite_env_propagator_b3_w3c_object.extract_context() + self.assertEqual(extracted_context , {}) + + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50f"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50f-136eec09c-01"}) + def test_extract_context_when_w3c_and_b3_traceid_and_spanid_are_invalid(self): + extracted_context = self.composite_env_propagator_b3_w3c_object.extract_context() + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,=value2"}) + def test_extract_context_when_baggage_object_is_not_passed_to_the_propagator(self): + extracted_context = self.composite_env_propagator_b3_w3c_object.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertIsNone(val1) + self.assertIsNone(val2) + + + ## Test cases for extract + + def test_extract_when_no_trace_details(self): + extracted_context = self.composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,=value2"}) + def test_extract_when_all_3_formats_are_valid(self): + extracted_context = self.composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertEqual(val1 , "value1") + self.assertIsNone(val2) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "=value1"}) + def test_extract_when_w3c_and_b3_formats_are_valid_and_baggage_invalid(self): + extracted_context = self.composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val = baggage.get_baggage("key1", extracted_context) + self.assertIsNone(val) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,key2=value2"}) + def test_extract_when_baggage_is_valid_but_w3c_and_b3_spanid_are_invalid(self): + extracted_context = self.composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(baggage.get_all(extracted_context) , {'key1':'value1', 'key2':'value2'}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,key2=value2"}) + def test_extract_when_baggage_is_valid_and_traceid_of_b3_and_w3c_have_16_hex_char(self): + extracted_context = self.composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '000000000000000098fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertEqual(val1 , "value1") + self.assertEqual(val2 , "value2") + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50f"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50f-136eec09c948be26-01"}) + def test_extract_when_w3c_and_b3_traceid_is_invalid(self): + extracted_context = self.composite_env_propagator_b3_w3c_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50f-136eec09c"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50f-136eec09c-01"}) + def test_extract_when_w3c_and_b3_traceid_and_spanid_are_invalid(self): + extracted_context = self.composite_env_propagator_b3_w3c_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,=value2"}) + def test_extract_when_baggage_object_is_not_passed_to_propagator(self): + extracted_context = self.composite_env_propagator_b3_w3c_object.extract(getter = getter, carrier = os.environ) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertIsNone(val1) + self.assertIsNone(val2) + + + @mock.patch.dict(os.environ, {"baggage": "example1-value1;example2-value2"}) + def test_extract_when_baggage_format_invalid(self): + extracted_context = self.composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"baggage": "example1=value1%2Cvalue2,example2=value3%2Cvalue4"}) + def test_extract_when_baggage_with_valid_format_has_commas_in_values(self): + extracted_context = self.composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(baggage.get_all(extracted_context) , {'example1':'value1,value2', 'example2':'value3,value4'}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) diff --git a/propagator/opentelemetry-propagator-env/tests/test_b3_single_env_propagator.py b/propagator/opentelemetry-propagator-env/tests/test_b3_single_env_propagator.py new file mode 100644 index 00000000000..e163a82b9f2 --- /dev/null +++ b/propagator/opentelemetry-propagator-env/tests/test_b3_single_env_propagator.py @@ -0,0 +1,309 @@ +# 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 os +import re +import unittest +from unittest import mock + +import opentelemetry +from opentelemetry.propagators.textmap import DefaultGetter, DefaultSetter +from opentelemetry.propagators.b3 import B3SingleFormat +from opentelemetry.propagators.env import ( + EnvPropagator, + CompositeEnvPropagator, +) +from tests.utils import create_invalid_context, create_dummy_context, create_dummy_context2, get_details_from_context, create_dummy_context_with_parent_span + +getter = DefaultGetter() +class TestB3EnvPropagator(unittest.TestCase): + def setUp(self): + self.mock_carrier = {} + self.env_propagator_b3_obj = EnvPropagator(B3SingleFormat()) + self.env_propagator_None_obj = EnvPropagator(None) + self.b3_object = B3SingleFormat() + + # Test cases for inject_to_carrier + + def test_inject_to_carrier_when_context_attached_has_invalid_span_context(self): + current_context = create_invalid_context() + token = opentelemetry.context.attach(current_context) + + env_b3 = self.env_propagator_b3_obj.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertIsNone(env_b3.get("traceparent")) + self.assertIsNone(env_b3.get("b3")) + + def test_inject_to_carrier_when_context_attached_has_valid_span_context(self): + dummy_context = create_dummy_context() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + + env_b3 = self.env_propagator_b3_obj.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertEqual(env_b3.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + self.assertIsNone(env_b3.get("traceparent")) + + def test_inject_to_carrier_when_None_object_passed_to_env_propagator_and_context_attached(self): + dummy_context = create_dummy_context() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + + env_None = self.env_propagator_None_obj.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertEqual(env_None.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + + + def test_inject_to_carrier_when_None_object_passed_to_env_propagator_and_context_passed_as_param(self): + dummy_context = create_dummy_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + + env_None = self.env_propagator_None_obj.inject_to_carrier(dummy_context) + self.assertEqual(env_None.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + + + def test_inject_to_carrier_when_context_passed_is_None(self): + dummy_context = create_dummy_context() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + + env_b3 = self.env_propagator_b3_obj.inject_to_carrier(None) + opentelemetry.context.detach(token) + self.assertEqual( env_b3.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + self.assertIsNone(env_b3.get("traceparent")) + + + def test_inject_to_carrier_when_valid_context_is_passed_as_param(self): + context_passed = create_dummy_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + + env_b3 = self.env_propagator_b3_obj.inject_to_carrier(context_passed) + self.assertEqual(env_b3.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + self.assertIsNone(env_b3.get("traceparent")) + + + def test_inject_to_carrier_when_context_attached_and_context_passed_as_param_are_different(self): + dummy_context = create_dummy_context2() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_dummy_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(dummy_context) + env_b3 = self.env_propagator_b3_obj.inject_to_carrier(context_passed) + opentelemetry.context.detach(token) + self.assertEqual(env_b3.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + self.assertNotEqual(env_b3.get("b3") , str(traceid2)+'-'+str(spanid2)+'-'+str(sampled2)) + self.assertIsNone(env_b3.get("traceparent")) + + # Test cases for extract_context + + @mock.patch.dict(os.environ, {}) + def test_extract_context_when_no_trace_details_in_b3_format(self): + extracted_context_b3 = self.env_propagator_b3_obj.extract_context() + self.assertEqual(extracted_context_b3 , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) + def test_extract_context_when_b3_valid_format_present(self): + extracted_context = self.env_propagator_b3_obj.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + self.assertEqual(tracestate , {}) + self.assertIsNone(parentspanid) + + @mock.patch.dict(os.environ, {'b3':'8128c5765-136eec09c948be26-1-e28bf981e15deb7f'}) + def test_extract_context_when_traceid_does_not_match_regex_for_b3_and_parent_span_id_present(self): + extracted_context_b3 = self.env_propagator_b3_obj.extract_context() + self.assertEqual(extracted_context_b3 , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c5-136eec09c948be26-1'}) + def test_extract_context_when_traceid_does_not_match_regex_for_b3_and_parent_span_id_not_present(self): + extracted_context_b3 = self.env_propagator_b3_obj.extract_context() + self.assertEqual(extracted_context_b3 , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136ee-1-e28bf981e15deb7f'}) + def test_extract_context_when_spanid_does_not_match_regex_for_b3_and_parent_span_id_present(self): + extracted_context_b3 = self.env_propagator_b3_obj.extract_context() + self.assertEqual(extracted_context_b3 , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136ee-1'}) + def test_extract_context_when_spanid_does_not_match_regex_for_b3_and_parent_span_id_not_present(self): + extracted_context_b3 = self.env_propagator_b3_obj.extract_context() + self.assertEqual(extracted_context_b3 , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136ee'}) + def test_extract_context_when_spanid_does_not_match_regex_for_b3_and_parent_span_id_and_sampled_not_present(self): + extracted_context_b3 = self.env_propagator_b3_obj.extract_context() + self.assertEqual(extracted_context_b3 , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c5-136ee-1-e28bf981e15deb7f'}) + def test_extract_context_when_traceid_and_spanid_do_not_match_regex_for_b3_and_parent_span_id_present(self): + extracted_context_b3 = self.env_propagator_b3_obj.extract_context() + self.assertEqual(extracted_context_b3 , {}) + + @mock.patch.dict(os.environ, {'b3': '8128c5-136ee-1'}) + def test_extract_context_when_traceid_and_spanid_do_not_match_regex_for_b3_and_parent_span_id_not_present(self): + extracted_context_b3 = self.env_propagator_b3_obj.extract_context() + self.assertEqual(extracted_context_b3 , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c5-136ee'}) + def test_extract_context_when_traceid_and_spanid_do_not_match_regex_for_b3_and_parent_span_id_and_sampled_not_present(self): + extracted_context_b3 = self.env_propagator_b3_obj.extract_context() + self.assertEqual(extracted_context_b3 , {}) + + # Test cases for inject + + def test_inject_when_valid_context_with_parent_span_id_is_passed_as_param(self): + test_context = create_dummy_context_with_parent_span() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + + self.env_propagator_b3_obj.inject(carrier = self.mock_carrier, context = test_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("b3") , str(trace_id)+"-"+str(span_id)+"-"+str(int(sampled_flag))+"-"+str(parent_span_id)) + + def test_inject_when_valid_context_without_parent_span_id_is_passed_as_params(self): + test_context = create_dummy_context() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + + self.env_propagator_b3_obj.inject(carrier = self.mock_carrier, context = test_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("b3") , str(trace_id)+"-"+str(span_id)+"-"+str(int(sampled_flag))) + + def test_inject_when_invalid_context_without_parent_span_id_is_passed_as_params(self): + test_context = create_invalid_context() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + + self.env_propagator_b3_obj.inject(carrier = self.mock_carrier, context = test_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_valid_context_with_parent_span_id_is_attached(self): + test_context = create_dummy_context_with_parent_span() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + token = opentelemetry.context.attach(test_context) + + self.env_propagator_b3_obj.inject(carrier = self.mock_carrier, context = test_context, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("b3") , str(trace_id)+"-"+str(span_id)+"-"+str(int(sampled_flag))+"-"+str(parent_span_id)) + + def test_inject_when_valid_context_without_parent_span_id_is_attached(self): + test_context = create_dummy_context() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + token = opentelemetry.context.attach(test_context) + + self.env_propagator_b3_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("b3") , str(trace_id)+"-"+str(span_id)+"-"+str(int(sampled_flag))) + + def test_inject_when_invalid_context_without_parent_span_id_is_attached(self): + test_context = create_invalid_context() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + token = opentelemetry.context.attach(test_context) + self.env_propagator_b3_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_context_attached_and_context_passed_as_param_are_different(self): + dummy_context = create_dummy_context2() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_dummy_context_with_parent_span() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(dummy_context) + self.env_propagator_b3_obj.inject(carrier = self.mock_carrier, context = context_passed, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)+'-'+str(parentspanid)) + self.assertNotEqual(self.mock_carrier.get("b3") , str(traceid2)+'-'+str(spanid2)+'-'+str(sampled2)) + + # Test cases for extract + + @mock.patch.dict(os.environ, {"b3":"8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f"}) + def test_extract_when_valid_b3format_with_parent_span_in_environment_variable(self): + extracted_context = self.env_propagator_b3_obj.extract(getter = getter, carrier = os.environ) + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(extracted_context) + self.assertEqual(trace_id , "8128c50fd8653b5d98fea4de58eca772") + self.assertEqual(span_id , "136eec09c948be26") + self.assertEqual(sampled_flag , 1) + self.assertEqual(tracestate , {}) + self.assertIsNone(parent_span_id) + + @mock.patch.dict(os.environ, {"b3":"8238c50fd8653b5d98fea4de58eca772-177eec09c948be26-1"}) + def test_extract_when_valid_b3format_without_parent_span_in_environment_variable(self): + extracted_context = self.env_propagator_b3_obj.extract(getter = getter, carrier = os.environ) + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(extracted_context) + self.assertEqual(trace_id , "8238c50fd8653b5d98fea4de58eca772") + self.assertEqual(span_id , "177eec09c948be26") + self.assertEqual(sampled_flag , 1) + self.assertEqual(tracestate , {}) + self.assertIsNone(parent_span_id) + + @mock.patch.dict(os.environ, {"b3":"8128c50fd8653b5d-177eec09c948be26-1-e28bf981e15deb7f"}) + def test_extract_b3format_with_16_hex_char_traceid_and_parent_span_id(self): + extracted_context = self.env_propagator_b3_obj.extract(getter = getter, carrier = os.environ) + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(extracted_context) + trace_id_match = re.fullmatch(self.b3_object._trace_id_regex, trace_id) + span_id_match = re.fullmatch(self.b3_object._span_id_regex, span_id) + self.assertEqual(trace_id , "00000000000000008128c50fd8653b5d") + self.assertEqual(span_id , "177eec09c948be26") + self.assertEqual(sampled_flag , 1) + self.assertNotEqual(trace_id_match , None) + self.assertNotEqual(span_id_match , None) + + @mock.patch.dict(os.environ, {"b3":"8128c50fd8653b5d-177eec09c948be26-1"}) + def test_extract_b3format_with_16_hex_char_traceid_and_no_parent_span_id(self): + extracted_context = self.env_propagator_b3_obj.extract(getter = getter, carrier = os.environ) + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(extracted_context) + trace_id_match = re.fullmatch(self.b3_object._trace_id_regex, trace_id) + span_id_match = re.fullmatch(self.b3_object._span_id_regex, span_id) + self.assertEqual(trace_id , "00000000000000008128c50fd8653b5d") + self.assertEqual(span_id , "177eec09c948be26") + self.assertEqual(sampled_flag , 1) + self.assertNotEqual(trace_id_match , None) + self.assertNotEqual(span_id_match , None) + + @mock.patch.dict(os.environ, {"b3":"8128c50-177eec09c948be26-1-e28bf981e15deb7f"}) + def test_extract_b3format_invalid_traceid_in_environment_variable_with_parent_span_id(self): + extracted_context = self.env_propagator_b3_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"b3":"8128c50-177eec09c948be26-1"}) + def test_extract_b3format_invalid_traceid_in_environment_variable_without_parent_span_id(self): + extracted_context = self.env_propagator_b3_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"b3":"8238c50fd8653b5d98fea4de58eca772-177eec09c-1-e28bf9eb7f"}) + def test_extract_b3format_invalid_span_id_in_environment_variable_with_parent_span_id(self): + extracted_context = self.env_propagator_b3_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"b3":"8238c50fd8653b5d98fea4de58eca772-177eec09c-1"}) + def test_extract_b3format_invalid_span_id_in_environment_variable_without_parent_span_id(self): + extracted_context = self.env_propagator_b3_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"b3":"8238c50fd8653b5d-177eec09c-1"}) + def test_extract_b3format_invalid_span_id_in_environment_variable_with_traceid_having_16_hex_char(self): + extracted_context = self.env_propagator_b3_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"b3":"8238c50-177eec09c-1-e28bf9"}) + def test_extract_b3format_invalid_trace_id_and_span_id_and_parent_id_in_environment_variable(self): + extracted_context = self.env_propagator_b3_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"b3":"8238c50ty8768698-177eec09c-a"}) + def test_extract_b3format_invalid_trace_id_and_span_id_and_sampled_in_environment_variable(self): + extracted_context = self.env_propagator_b3_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {}) + def test_extract_b3format_when_no_trace_details(self): + extracted_context = self.env_propagator_b3_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) diff --git a/propagator/opentelemetry-propagator-env/tests/test_b3_single_format_baggage_composite_env_propagator.py b/propagator/opentelemetry-propagator-env/tests/test_b3_single_format_baggage_composite_env_propagator.py new file mode 100644 index 00000000000..f6398c03d47 --- /dev/null +++ b/propagator/opentelemetry-propagator-env/tests/test_b3_single_format_baggage_composite_env_propagator.py @@ -0,0 +1,445 @@ +# 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 os +import unittest +from unittest import mock + +import opentelemetry +from opentelemetry import baggage +from opentelemetry.propagators.textmap import DefaultGetter, DefaultSetter +from opentelemetry.propagators.b3 import B3SingleFormat +from opentelemetry.propagators.env import ( # pylint: disable=no-name-in-module + CompositeEnvPropagator, +) +from opentelemetry.baggage.propagation import W3CBaggagePropagator +from tests.utils import * + +getter = DefaultGetter() +class TestB3BaggageCompositeEnvPropagator(unittest.TestCase): + def setUp(self): + self.mock_carrier = {} + self.composite_env_propagator_b3_baggage_object = CompositeEnvPropagator([B3SingleFormat(), W3CBaggagePropagator()]) + self.composite_env_propagator_None_obj = CompositeEnvPropagator(None) + + # Test cases for inject_to_carrier + + def test_inject_to_carrier_when_valid_context_with_baggage_attached(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_baggage_object.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + + def test_inject_to_carrier_when_invalid_context_with_baggage_attached(self): + current_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(current_context) + self.mock_carrier = self.composite_env_propagator_b3_baggage_object.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + + def test_inject_to_carrier_when_valid_context_with_baggage_passed(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_baggage_object.inject_to_carrier(context = dummy_context) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + + def test_inject_to_carrier_when_valid_context_with_no_baggage_passed(self): + dummy_context = create_dummy_context_with_parent_span() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_baggage_object.inject_to_carrier(context = dummy_context) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)+'-'+str(parentspanid)) + self.assertIsNone(self.mock_carrier.get("baggage")) + + def test_inject_to_carrier_when_invalid_context_with_baggage_passed(self): + dummy_context = create_invalid_context_with_baggage() + self.mock_carrier = self.composite_env_propagator_b3_baggage_object.inject_to_carrier(context = dummy_context) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + + def test_inject_to_carrier_when_context_attached_and_context_passed_are_different(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_valid_context_with_baggage2() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_baggage_object.inject_to_carrier(context_passed) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + self.assertNotEqual(self.mock_carrier.get("b3") , str(traceid2)+'-'+str(spanid2)+'-'+str(sampled2)) + self.assertEqual(self.mock_carrier.get("baggage") , "key3=1,key4=2") + self.assertNotEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + + + # Test cases for inject when None object passed to composite_propagator + + ## for valid context + + def test_inject_with_None_object_passed_to_composite_propagator_and_valid_context_attached(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_with_None_object_passed_to_composite_propagator_and_valid_context_passed_as_param(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_obj.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_with_None_object_passed_to_composite_propagator_when_valid_context_with_baggage_attached(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_obj.inject(carrier = self.mock_carrier, context = None, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_with_None_object_passed_to_composite_propagator_when_valid_context_without_baggage_attached(self): + dummy_context = create_dummy_context_with_parent_span() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("b3")) + + # for invalid context + + def test_inject_with_None_object_passed_to_composite_propagator_and_invalid_context_attached(self): + dummy_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_with_None_object_passed_to_composite_propagator_and_invalid_context_passed_as_param(self): + dummy_context = create_invalid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_obj.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + # other Test cases for inject + + ## For valid context + + def test_inject_when_valid_context_without_baggage_attached(self): + dummy_context = create_dummy_context_with_parent_span() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)+'-'+str(parentspanid)) + + + def test_inject_when_valid_context_with_baggage_attached(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + + + def test_inject_when_valid_context_without_baggage_passed_as_param(self): + dummy_context = create_dummy_context_with_parent_span() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)+'-'+str(parentspanid)) + + + def test_inject_when_valid_context_with_baggage_passed_as_param(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + + + def test_inject_when_context_with_baggage_attached_and_context_with_baggage_passed_as_param_are_different(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_valid_context_with_baggage2() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(context_passed) + self.composite_env_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, context = context_passed, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid2)+'-'+str(spanid2)+'-'+str(sampled2)) + self.assertEqual(self.mock_carrier.get("baggage") , "key3=1,key4=2") + + def test_inject_when_context_attached_and_context_passed_without_baggage_are_different(self): + dummy_context = create_dummy_context() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_dummy_context2() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, context = context_passed, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + + def test_inject_when_traceid_has_16_hex_char(self): + dummy_context = create_dummy_context3() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + + ## For invalid context + + def test_inject_when_invalid_context_without_baggage_attached(self): + dummy_context = create_invalid_context() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_invalid_context_with_baggage_attached(self): + dummy_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_invalid_context_without_baggage_passed_as_param(self): + dummy_context = create_invalid_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_invalid_context_with_baggage_passed_as_param(self): + dummy_context = create_invalid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_baggage_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + + # Test cases for extract + + def test_extract_when_no_context_present(self): + extracted_context = self.composite_env_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01'}) + @mock.patch.dict(os.environ, {'baggage':'key1=value1,=value2'}) + def test_extract_when_b3_and_baggage_are_valid(self): + extracted_context = self.composite_env_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_all(extracted_context) + self.assertEqual(val1 , "value1") + self.assertEqual(val2 , {'key1':'value1', '':'value2'}) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01'}) + @mock.patch.dict(os.environ, {'baggage':'value1-'}) + def test_extract_when_b3_format_is_valid_and_baggage_invalid(self): + extracted_context = self.composite_env_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val = baggage.get_all(extracted_context) + self.assertEqual(val , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c-01'}) + @mock.patch.dict(os.environ, {'baggage':'key1=value1,key2=value2'}) + def test_extract_when_baggage_is_valid_but_b3_spanid_is_invalid(self): + extracted_context = self.composite_env_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) + self.assertEqual(baggage.get_all(extracted_context) , {'key1':'value1', 'key2':'value2'}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + @mock.patch.dict(os.environ, {'b3':'98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-000000000000000098fea4de58eca772-136eec09c948be26-01'}) + @mock.patch.dict(os.environ, {'baggage':'key1=value1,key2=value2'}) + def test_extract_when_baggage_is_valid_and_traceid_of_b3_has_16_hex_char(self): + extracted_context = self.composite_env_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '000000000000000098fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + baggage_values = baggage.get_all(extracted_context) + self.assertEqual(baggage_values , {'key1':'value1','key2':'value2'}) + + @mock.patch.dict(os.environ, {'b3':'8128c50f-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de34111111-136eec09c948be26-01'}) + def test_extract_when_b3_traceid_is_invalid(self): + extracted_context = self.composite_env_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50f-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de34111111-136eec09c-01'}) + def test_extract_when_b3_traceid_and_spanid_are_invalid(self): + extracted_context = self.composite_env_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01'}) + @mock.patch.dict(os.environ, {'baggage':'key1=value1,=value2'}) + def test_extract_when_a_baggage_key_is_not_passed(self): + extracted_context = self.composite_env_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + self.assertEqual(baggage.get_all(extracted_context) , {'key1':'value1', '':'value2'}) + + @mock.patch.dict(os.environ, {'baggage':'example1-value1;example2-value2'}) + def test_extract_baggage_invalid_format(self): + extracted_context = self.composite_env_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) + self.assertEqual(extracted_context, {}) + + @mock.patch.dict(os.environ, {'baggage':'example1=value1%2Cvalue2,example2=value3%2Cvalue4'}) + def test_extract_when_baggage_with_valid_format_has_commas_in_values(self): + extracted_context = self.composite_env_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) + self.assertEqual(baggage.get_all(extracted_context) , {'example1':'value1,value2', 'example2':'value3,value4'}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + # Test cases for extract_context + + def test_extract_context_when_no_context_present(self): + extracted_context = self.composite_env_propagator_b3_baggage_object.extract_context() + self.assertEqual(extracted_context ,{}) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01'}) + @mock.patch.dict(os.environ, {'baggage':'key1=value1,=value2'}) + def test_extract_context_when_b3_and_baggage_are_valid(self): + extracted_context = self.composite_env_propagator_b3_baggage_object.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_all(extracted_context) + self.assertEqual(val1 , "value1") + self.assertEqual(val2 , {'key1':'value1', '':'value2'}) + + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01'}) + @mock.patch.dict(os.environ, {'baggage':'=value1'}) + def test_extract_context_when_b3_format_is_valid_and_a_baggage_key_is_empty_string(self): + extracted_context = self.composite_env_propagator_b3_baggage_object.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val = baggage.get_all(extracted_context) + self.assertEqual(val , {'':'value1'}) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c-01'}) + @mock.patch.dict(os.environ, {'baggage':'key1=value1,key2=value2'}) + def test_extract_context_when_baggage_is_valid_but_b3_spanid_is_invalid(self): + extracted_context = self.composite_env_propagator_b3_baggage_object.extract_context() + self.assertEqual(baggage.get_all(extracted_context) , {'key1':'value1', 'key2':'value2'}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + + @mock.patch.dict(os.environ, {'b3':'88128c50f-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de56a789da-136eec09c948be27-01'}) + def test_extract_context_when_b3_traceid_is_invalid(self): + extracted_context = self.composite_env_propagator_b3_baggage_object.extract_context() + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50f-136eec09c-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de-136eec09c-01'}) + def test_extract_context_when_b3_traceid_and_spanid_are_invalid(self): + extracted_context = self.composite_env_propagator_b3_baggage_object.extract_context() + self.assertEqual(extracted_context , {}) + + + @mock.patch.dict(os.environ, {'b3':'98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-000000000000000098fea4de58eca772-136eec09c948be26-01'}) + @mock.patch.dict(os.environ, {'baggage':'key1=value1,key2=value2'}) + def test_extract_context_when_baggage_is_valid_and_traceid_of_b3_has_16_hex_char(self): + extracted_context = self.composite_env_propagator_b3_baggage_object.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '000000000000000098fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertEqual(val1 , "value1") + self.assertEqual(val2 , "value2") + + @mock.patch.dict(os.environ, {'baggage':'example1-value1;example2-value2'}) + def test_extract_context_when_baggage_invalid_format(self): + extracted_context = self.composite_env_propagator_b3_baggage_object.extract_context() + val1 = baggage.get_baggage("example1", extracted_context) + val2 = baggage.get_baggage("example2", extracted_context) + self.assertNotEqual(val1, "value1") + self.assertNotEqual(val2 , "value2") + self.assertIsNone(val1) + self.assertIsNone(val2) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + @mock.patch.dict(os.environ, {'baggage':'example1=value1%2Cvalue2,example2=value3%2Cvalue4'}) + def test_extract_context_when_baggage_with_valid_format_has_commas_in_values(self): + extracted_context = self.composite_env_propagator_b3_baggage_object.extract_context() + val1 = baggage.get_baggage("example1", extracted_context) + val2 = baggage.get_baggage("example2", extracted_context) + self.assertEqual(val1 , "value1,value2") + self.assertEqual(val2 , "value3,value4") + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) diff --git a/propagator/opentelemetry-propagator-env/tests/test_b3_single_format_composite_env_propagator.py b/propagator/opentelemetry-propagator-env/tests/test_b3_single_format_composite_env_propagator.py new file mode 100644 index 00000000000..c5f34f017b5 --- /dev/null +++ b/propagator/opentelemetry-propagator-env/tests/test_b3_single_format_composite_env_propagator.py @@ -0,0 +1,347 @@ +# 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 os +import re +import unittest +from unittest import mock + +import opentelemetry +from opentelemetry.propagators.textmap import DefaultGetter, DefaultSetter +from opentelemetry.propagators.b3 import B3SingleFormat +from opentelemetry.propagators.env.composite_propagator import CompositeEnvPropagator +from tests.utils import create_valid_context_with_baggage, create_valid_context_with_baggage2, create_dummy_context_with_parent_span +from tests.utils import * + +getter = DefaultGetter() +class TestB3CompositeEnvPropagator(unittest.TestCase): + def setUp(self): + self.mock_carrier = {} + self.b3_composite_env_propagator_object = CompositeEnvPropagator([B3SingleFormat()]) + self.composite_env_propagator_None_obj = CompositeEnvPropagator(None) + self.b3_object = B3SingleFormat() + + # Test cases for inject_to_carrier + + def test_inject_to_carrier_when_valid_context_with_baggage_attached(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.b3_composite_env_propagator_object.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + + def test_inject_to_carrier_when_valid_context_with_baggage_passed_as_param(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.b3_composite_env_propagator_object.inject_to_carrier(context = dummy_context) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + self.assertIsNone( self.mock_carrier.get("baggage")) + + def test_inject_to_carrier_when_valid_context_passed_as_param_without_baggage(self): + dummy_context = create_dummy_context_with_parent_span() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.b3_composite_env_propagator_object.inject_to_carrier(context = dummy_context) + self.assertIsNone( self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)+'-'+str(parentspanid)) + self.assertIsNone( self.mock_carrier.get("baggage")) + + def test_inject_to_carrier_when_context_attached_and_context_passed_with_baggage_are_different(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_valid_context_with_baggage2() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(context_passed) + self.mock_carrier = self.b3_composite_env_propagator_object.inject_to_carrier(context_passed) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid2)+'-'+str(spanid2)+'-'+str(sampled2)) + self.assertNotEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + + def test_inject_to_carrier_when_invalid_context_passed(self): + dummy_context = create_invalid_context_with_baggage() + self.mock_carrier = self.b3_composite_env_propagator_object.inject_to_carrier(context = dummy_context) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertIsNone(self.mock_carrier.get("baggage")) + + def test_inject_to_carrier_when_invalid_context_attached(self): + current_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(current_context) + self.mock_carrier = self.b3_composite_env_propagator_object.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertIsNone(self.mock_carrier.get("baggage")) + + ## Test cases for inject + + def test_inject_b3format_when_valid_context_with_parent_span_id_attached(self): + test_context = create_dummy_context_with_parent_span() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + token = opentelemetry.context.attach(test_context) + self.b3_composite_env_propagator_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + if parent_span_id is not None: + self.assertEqual(self.mock_carrier.get("b3") , str(trace_id)+"-"+str(span_id)+"-"+str(int(sampled_flag))+"-"+str(parent_span_id)) + + def test_inject_b3format_when_valid_context_without_parent_span_id_attached(self): + test_context = create_dummy_context() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + token = opentelemetry.context.attach(test_context) + self.b3_composite_env_propagator_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("b3") , str(trace_id)+"-"+str(span_id)+"-"+str(int(sampled_flag))) + + def test_inject_b3format_when_valid_context_with_parent_span_id_passed_as_param(self): + test_context = create_dummy_context_with_parent_span() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + self.b3_composite_env_propagator_object.inject(carrier = self.mock_carrier, context = test_context, setter = DefaultSetter()) + if parent_span_id is not None: + self.assertEqual(self.mock_carrier.get("b3") , str(trace_id)+"-"+str(span_id)+"-"+str(int(sampled_flag))+"-"+str(parent_span_id)) + + def test_inject_b3format_when_valid_context_without_parent_span_id_passed_as_param(self): + test_context = create_dummy_context() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + self.b3_composite_env_propagator_object.inject(carrier = self.mock_carrier, context = test_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("b3") , str(trace_id)+"-"+str(span_id)+"-"+str(int(sampled_flag))) + + + def test_inject_b3format_when_invalid_context_attached(self): + test_context = create_invalid_context() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + token = opentelemetry.context.attach(test_context) + self.b3_composite_env_propagator_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_b3format_when_invalid_context_passed_as_param(self): + test_context = create_invalid_context() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + self.b3_composite_env_propagator_object.inject(carrier = self.mock_carrier, context = test_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_b3format_when_invalid_context_with_baggage_attached(self): + test_context = create_invalid_context_with_baggage() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + token = opentelemetry.context.attach(test_context) + self.b3_composite_env_propagator_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertIsNone(self.mock_carrier.get("baggage")) + + def test_inject_b3format_when_invalid_context_with_baggage_passed_as_param(self): + test_context = create_invalid_context_with_baggage() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + self.b3_composite_env_propagator_object.inject(carrier = self.mock_carrier, context = test_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertIsNone(self.mock_carrier.get("baggage") ) + + def test_inject_when_context_attached_and_context_passed_as_param_are_different(self): + dummy_context = create_dummy_context2() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_dummy_context_with_parent_span() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(dummy_context) + self.b3_composite_env_propagator_object.inject(carrier = self.mock_carrier, context = context_passed, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)+'-'+str(parentspanid)) + self.assertNotEqual(self.mock_carrier.get("b3") , str(traceid2)+'-'+str(spanid2)+'-'+str(sampled2)) + + # Test cases for extract + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) + def test_extract_b3format_valid_format_with_parent_span_present(self): + extracted_context = self.b3_composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(extracted_context) + self.assertEqual(trace_id , "8128c50fd8653b5d98fea4de58eca772") + self.assertEqual(span_id , "136eec09c948be26") + self.assertEqual(sampled_flag , 1) + self.assertIsNone(parent_span_id) + self.assertEqual(tracestate , {}) + + @mock.patch.dict(os.environ, {'b3':'8238c50fd8653b5d98fea4de58eca772-177eec09c948be26-1'}) + def test_extract_b3format_valid_format_without_parent_span_present(self): + extracted_context = self.b3_composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(extracted_context) + self.assertEqual(trace_id , "8238c50fd8653b5d98fea4de58eca772") + self.assertEqual(span_id , "177eec09c948be26") + self.assertEqual(sampled_flag , 1) + self.assertIsNone(parent_span_id) + self.assertEqual(tracestate , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d-177eec09c948be26-1-e28bf981e15deb7f'}) + def test_extract_b3format_with_16_hex_char_traceid_and_parent_span_id_present(self): + extracted_context = self.b3_composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(extracted_context) + trace_id_match = re.fullmatch(self.b3_object._trace_id_regex, trace_id) + span_id_match = re.fullmatch(self.b3_object._span_id_regex, span_id) + self.assertEqual(trace_id , "00000000000000008128c50fd8653b5d") + self.assertEqual(span_id , "177eec09c948be26") + self.assertEqual(sampled_flag , 1) + self.assertNotEqual(trace_id_match , None) + self.assertNotEqual(span_id_match , None) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d-177eec09c948be26-1'}) + def test_extract_b3format_with_16_hex_char_traceid_and_no_parent_span_id(self): + extracted_context = self.b3_composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(extracted_context) + trace_id_match = re.fullmatch(self.b3_object._trace_id_regex, trace_id) + span_id_match = re.fullmatch(self.b3_object._span_id_regex, span_id) + self.assertEqual(trace_id , "00000000000000008128c50fd8653b5d") + self.assertEqual(span_id , "177eec09c948be26") + self.assertEqual(sampled_flag , 1) + self.assertNotEqual(trace_id_match , None) + self.assertNotEqual(span_id_match , None) + + @mock.patch.dict(os.environ, {'b3':'8128c50-177eec09c948be26-1-e28bf981e15deb7f'}) + def test_extract_b3format_invalid_traceid_in_environment_variable_with_parent_span_id_present(self): + extracted_context = self.b3_composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50-177eec09c948be26-1'}) + def test_extract_b3format_invalid_traceid_in_environment_variable_without_parent_span_id_present(self): + extracted_context = self.b3_composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {'b3':'8238c50fd8653b5d98fea4de58eca772-177eec09c-1-e28bf9eb7f'}) + def test_extract_b3format_invalid_span_id_in_environment_variable_with_parent_span_id_present(self): + extracted_context = self.b3_composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {'b3':'8238c50fd8653b5d98fea4de58eca772-177eec09c-1'}) + def test_extract_b3format_invalid_span_id_in_environment_variable_without_parent_span_id_present(self): + extracted_context = self.b3_composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {'b3':'8238c50fd8653b5d-177eec09c-1'}) + def test_extract_b3format_invalid_span_id_in_environment_variable_with_16_hex_char_traceid(self): + extracted_context = self.b3_composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {'b3':'8238c50-177eec09c-1-e28bf9'}) + def test_extract_b3format_with_invalid_trace_id_and_span_id_and_parent_id_in_environment_variable(self): + extracted_context = self.b3_composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {'b3':'8238c50ty8768698-177eec09c-a'}) + def test_extract_b3format_invalid_trace_id_and_span_id_and_sampled_in_environment_variable(self): + extracted_context = self.b3_composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {}) + def test_extract_b3format_when_no_trace_details(self): + extracted_context = self.b3_composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + # Test cases for extract_context + + @mock.patch.dict(os.environ, {}) + def test_extract_context_when_no_trace_details(self): + extracted_context = self.b3_composite_env_propagator_object.extract_context() + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) + def test_extract_context_when_valid_format_in_environment_variable_with_parent_span_present(self): + extracted_context = self.b3_composite_env_propagator_object.extract_context() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(extracted_context) + self.assertEqual(trace_id , "8128c50fd8653b5d98fea4de58eca772") + self.assertEqual(span_id , "136eec09c948be26") + self.assertEqual(sampled_flag , 1) + self.assertEqual(tracestate , {}) + + @mock.patch.dict(os.environ, {'b3':'8238c50fd8653b5d98fea4de58eca772-177eec09c948be26-1'}) + def test_extract_context_when_valid_format_in_environment_variable_without_parent_span_present(self): + extracted_context = self.b3_composite_env_propagator_object.extract_context() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(extracted_context) + self.assertEqual(trace_id , "8238c50fd8653b5d98fea4de58eca772") + self.assertEqual(span_id , "177eec09c948be26") + self.assertEqual(sampled_flag , 1) + self.assertEqual(tracestate , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d-177eec09c948be26-1-e28bf981e15deb7f'}) + def test_extract_context_when_valid_format_in_environment_variable_with_16_hex_char_traceid_and_parent_span_present(self): + extracted_context = self.b3_composite_env_propagator_object.extract_context() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(extracted_context) + trace_id_match = re.fullmatch(self.b3_object._trace_id_regex, trace_id) + span_id_match = re.fullmatch(self.b3_object._span_id_regex, span_id) + self.assertEqual(trace_id , "00000000000000008128c50fd8653b5d") + self.assertEqual(span_id , "177eec09c948be26") + self.assertEqual(sampled_flag , 1) + self.assertNotEqual(trace_id_match , None) + self.assertNotEqual(span_id_match , None) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d-177eec09c948be26-1'}) + def test_extract_context_when_valid_format_in_environment_variable_with_16_hex_char_traceid_and_no_parent_span_present(self): + extracted_context = self.b3_composite_env_propagator_object.extract_context() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(extracted_context) + trace_id_match = re.fullmatch(self.b3_object._trace_id_regex, trace_id) + span_id_match = re.fullmatch(self.b3_object._span_id_regex, span_id) + self.assertEqual(trace_id , "00000000000000008128c50fd8653b5d") + self.assertEqual(span_id , "177eec09c948be26") + self.assertEqual(sampled_flag , 1) + self.assertNotEqual(trace_id_match , None) + self.assertNotEqual(span_id_match , None) + + @mock.patch.dict(os.environ, {'b3':'8128c50-177eec09c948be26-1-e28bf981e15deb7f'}) + def test_extract_context_when_invalid_traceid_in_environment_variable_with_parent_span_present(self): + extracted_context = self.b3_composite_env_propagator_object.extract_context() + self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + @mock.patch.dict(os.environ, {'b3':'8128c50-177eec09c948be26-1'}) + def test_extract_context_when_invalid_traceid_in_environment_variable_without_parent_span_present(self): + extracted_context = self.b3_composite_env_propagator_object.extract_context() + self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + @mock.patch.dict(os.environ, {'b3':'8238c50fd8653b5d98fea4de58eca772-177eec09c-1-e28bf9eb7f233342'}) + def test_extract_context_when_invalid_span_id_in_environment_variable_with_valid_parent_span_id_present(self): + extracted_context = self.b3_composite_env_propagator_object.extract_context() + self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + @mock.patch.dict(os.environ, {'b3':'8238c50fd8653b5d98fea4de58eca772-177eec09c-1-e28bf9eb7f'}) + def test_extract_context_when_span_id_and_parent_span_id_invalid_in_environment_variable(self): + extracted_context = self.b3_composite_env_propagator_object.extract_context() + self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + @mock.patch.dict(os.environ, {'b3':'8238c50fd8653b5d98fea4de58eca772-177eec09c-1'}) + def test_extract_context_when_invalid_span_id_in_environment_variable_without_parent_span_present(self): + extracted_context = self.b3_composite_env_propagator_object.extract_context() + self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + @mock.patch.dict(os.environ, {'b3':'8238c50fd8653b5d-177eec09c-1'}) + def test_extract_context_when_invalid_span_id_in_environment_variable_with_16_hex_char_trace_id_and_without_parent_span_present(self): + extracted_context = self.b3_composite_env_propagator_object.extract_context() + self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + @mock.patch.dict(os.environ, {'b3':'8238c50ty8768698-177eec09c-1-e28bf9'}) + def test_extract_context_when_trace_id_span_id_and_parent_span_id_invalid_in_environment_variable(self): + extracted_context = self.b3_composite_env_propagator_object.extract_context() + self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + @mock.patch.dict(os.environ, {'b3':'8238c50ty8768698-177eec09c-a'}) + def test_extract_context_when_trace_id_span_id_and_sampled_invalid_in_environment_variable(self): + extracted_context = self.b3_composite_env_propagator_object.extract_context() + self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) diff --git a/propagator/opentelemetry-propagator-env/tests/test_b3_single_format_tracecontext_composite_env_propagator.py b/propagator/opentelemetry-propagator-env/tests/test_b3_single_format_tracecontext_composite_env_propagator.py new file mode 100644 index 00000000000..12a0ac221db --- /dev/null +++ b/propagator/opentelemetry-propagator-env/tests/test_b3_single_format_tracecontext_composite_env_propagator.py @@ -0,0 +1,586 @@ +# 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 os +import unittest +from unittest import mock + +import opentelemetry +from opentelemetry import baggage +from opentelemetry.propagators.textmap import DefaultGetter, DefaultSetter +from opentelemetry.trace.propagation import tracecontext +from opentelemetry.propagators.b3 import B3SingleFormat +from opentelemetry.baggage.propagation import W3CBaggagePropagator +from opentelemetry.propagators.env.composite_propagator import CompositeEnvPropagator +from tests.utils import * + +getter = DefaultGetter() +class TestB3TracecontextCompositeEnvPropagator(unittest.TestCase): + def setUp(self): + self.mock_carrier = {} + self.composite_env_propagator_b3_w3c_obj = CompositeEnvPropagator([B3SingleFormat(), tracecontext.TraceContextTextMapPropagator()]) + self.composite_env_propagator_None_obj = CompositeEnvPropagator(None) + self.composite_env_propagator_obj = CompositeEnvPropagator([B3SingleFormat(), tracecontext.TraceContextTextMapPropagator(), W3CBaggagePropagator()]) + + # Test case for inject + def test_inject_when_None_object_passed_to_propagator_and_valid_context_attached(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent"), '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage"), "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + # here context is invalid but baggage is valid + def test_inject_when_None_object_passed_to_propagator_and_invalid_context_attached(self): + dummy_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage"), "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_None_object_passed_to_propagator_and_valid_context_passed_as_param(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_obj.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_None_object_passed_to_propagator_and_invalid_context_passed_as_param(self): + dummy_context = create_invalid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_obj.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_None_object_passed_to_propagator_and_valid_context_attached_and_None_context_passed_as_param(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_obj.inject(carrier = self.mock_carrier, context = None, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_None_object_passed_to_propagator_and_valid_context_without_baggage_attached(self): + dummy_context = create_dummy_context_with_parent_span() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_valid_context_without_baggage_attached_for_w3c_and_b3(self): + dummy_context = create_dummy_context_with_parent_span() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_w3c_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)+'-'+str(parentspanid)) + + def test_inject_when_invalid_context_without_baggage_attached_for_w3c_and_b3(self): + dummy_context = create_invalid_context() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_w3c_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_valid_context_with_baggage_attached_for_w3c_and_b3(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_w3c_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + + + def test_inject_when_invalid_context_with_baggage_attached_for_w3c_and_b3(self): + dummy_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_w3c_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_valid_context_without_baggage_passed_as_param_for_w3c_and_b3(self): + dummy_context = create_dummy_context_with_parent_span() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_w3c_obj.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)+'-'+str(parentspanid)) + + def test_inject_when_valid_context_with_baggage_passed_as_param_for_w3c_and_b3(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_w3c_obj.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + + def test_inject_when_invalid_context_without_baggage_passed_as_param_for_w3c_and_b3(self): + dummy_context = create_invalid_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_w3c_obj.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("b3")) + + + def test_inject_when_invalid_context_with_baggage_passed_as_param_for_w3c_and_b3(self): + dummy_context = create_invalid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_w3c_obj.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_context_attached_and_context_passed_as_param_with_baggage_are_different_for_w3c_and_b3(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_valid_context_with_baggage2() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_w3c_obj.inject(carrier = self.mock_carrier, context = context_passed, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + + def test_inject_when_context_attached_and_context_passed_as_param_without_baggage_are_different_for_w3c_and_b3(self): + dummy_context = create_dummy_context() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_dummy_context2() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(dummy_context) + self.composite_env_propagator_b3_w3c_obj.inject(carrier = self.mock_carrier, context = context_passed, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + + def test_inject_when_valid_context_with_baggage_attached_for_all_3_formats(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + + def test_inject_when_valid_context_without_baggage_attached_for_all_3_formats(self): + dummy_context = create_dummy_context_with_parent_span() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)+'-'+str(parentspanid)) + + def test_inject_when_invalid_context_with_baggage_attached_or_all_3_formats(self): + current_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(current_context) + self.composite_env_propagator_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_valid_context_with_baggage_passed_as_params_for_all_3_formats(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_obj.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertEqual( self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + + def test_inject_when_valid_context_without_baggage_passed_as_param_for_all_3_formats(self): + dummy_context = create_dummy_context_with_parent_span() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_obj.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("b3"), str(traceid)+'-'+str(spanid)+'-'+str(sampled)+'-'+str(parentspanid)) + + def test_inject_when_invalid_context_with_baggage_passed_as_params_for_all_3_formats(self): + dummy_context = create_invalid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_obj.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage"), "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_traceid_has_16_hex_char(self): + dummy_context = create_dummy_context3() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_obj.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("b3"), str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + self.assertEqual(self.mock_carrier.get("traceparent"), '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + + # Test cases for for inject_to_carrier w3c and b3 formats with/without baggage + + def test_inject_to_carrier_when_valid_context_without_baggage_attached_for_w3c_and_b3(self): + dummy_context = create_dummy_context_with_parent_span() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_obj.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent"), '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("b3"), str(traceid)+'-'+str(spanid)+'-'+str(sampled)+'-'+str(parentspanid)) + + def test_inject_to_carrier_when_invalid_context_without_baggage_attached_for_w3c_and_b3(self): + dummy_context = create_invalid_context() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_obj.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_valid_context_with_baggage_attached_for_w3c_and_b3(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_obj.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent"), '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("b3"), str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + + def test_inject_to_carrier_when_invalid_context_with_baggage_attached_for_w3c_and_b3(self): + dummy_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_obj.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_valid_context_without_baggage_passed_as_param_for_w3c_and_b3(self): + dummy_context = create_dummy_context_with_parent_span() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_obj.inject_to_carrier(context = dummy_context) + self.assertEqual(self.mock_carrier.get("traceparent"), '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("b3"), str(traceid)+'-'+str(spanid)+'-'+str(sampled)+'-'+str(parentspanid)) + + def test_inject_to_carrier_when_invalid_context_without_baggage_passed_as_param_for_w3c_and_b3(self): + dummy_context = create_invalid_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_obj.inject_to_carrier(context = dummy_context) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_valid_context_with_baggage_passed_as_param_for_w3c_and_b3(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_obj.inject_to_carrier(context = dummy_context) + self.assertEqual(self.mock_carrier.get("traceparent"), '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("b3"), str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + + def test_inject_to_carrier_when_invalid_context_with_baggage_passed_as_param_for_w3c_and_b3(self): + dummy_context = create_invalid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_obj.inject_to_carrier(context = dummy_context) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_context_attached_and_context_passed_as_param_with_baggage_are_different_for_w3c_and_b3(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_valid_context_with_baggage2() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(context_passed) + self.mock_carrier = self.composite_env_propagator_b3_w3c_obj.inject_to_carrier(context_passed) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent"), '00'+'-'+str(traceid2)+'-'+str(spanid2)+'-'+'0'+str(sampled2)) + self.assertEqual(self.mock_carrier.get("b3"), str(traceid2)+'-'+str(spanid2)+'-'+str(sampled2)) + self.assertIsNone(self.mock_carrier.get("baggage")) + + def test_inject_to_carrier_when_context_attached_and_context_passed_as_params_without_baggage_are_different_for_w3c_and_b3(self): + dummy_context = create_dummy_context() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_dummy_context2() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(context_passed) + self.mock_carrier = self.composite_env_propagator_b3_w3c_obj.inject_to_carrier(context_passed) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent"), '00'+'-'+str(traceid2)+'-'+str(spanid2)+'-'+'0'+str(sampled2)) + self.assertEqual(self.mock_carrier.get("b3"), str(traceid2)+'-'+str(spanid2)+'-'+str(sampled2)) + self.assertIsNone(self.mock_carrier.get("baggage")) + + def test_inject_to_carrier_when_valid_context_with_baggage_attached_for_all_3_formats(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_obj.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent"), '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage"), "key1=1,key2=2") + self.assertEqual(self.mock_carrier.get("b3"), str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + + def test_inject_to_carrier_when_valid_context_without_baggage_attached_for_all_3_formats(self): + dummy_context = create_dummy_context_with_parent_span() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_obj.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent"), '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("b3"), str(traceid)+'-'+str(spanid)+'-'+str(sampled)+'-'+str(parentspanid)) + + def test_inject_to_carrier_when_invalid_context_with_baggage_attached_for_all_3_formats(self): + current_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(current_context) + self.mock_carrier = self.composite_env_propagator_obj.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage"), "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_valid_context_with_baggage_passed_for_all_3_formats(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_obj.inject_to_carrier(context = dummy_context) + self.assertEqual(self.mock_carrier.get("traceparent"),'00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage"), "key1=1,key2=2") + self.assertEqual(self.mock_carrier.get("b3"), str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + + def test_inject_to_carrier_when_valid_context_without_baggage_passed_for_all_3_formats(self): + dummy_context = create_dummy_context_with_parent_span() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_obj.inject_to_carrier(context = dummy_context) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)+'-'+str(parentspanid)) + + def test_inject_to_carrier_when_invalid_context_with_baggage_passed_for_all_3_formats(self): + dummy_context = create_invalid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_obj.inject_to_carrier(context = dummy_context) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_traceid_has_16_hex_char(self): + dummy_context = create_dummy_context3() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_obj.inject_to_carrier(context = dummy_context) + self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + + # Test cases for extract_context + + def test_extract_context_when_no_trace_details_in_environment_variable(self): + extracted_context = self.composite_env_propagator_obj.extract_context() + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01'}) + @mock.patch.dict(os.environ, {'baggage':'key1=value1,=value2'}) + def test_extract_context_when_all_3_formats_are_valid(self): + extracted_context = self.composite_env_propagator_obj.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_all( extracted_context) + self.assertEqual(val1 , "value1") + self.assertEqual(val2 , {'key1':'value1','':'value2'}) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01'}) + @mock.patch.dict(os.environ, {'baggage':'/value'}) + def test_extract_context_when_w3c_and_b3_formats_are_valid_and_baggage_invalid(self): + extracted_context = self.composite_env_propagator_obj.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val = baggage.get_all(extracted_context) + self.assertEqual(val , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c-01'}) + @mock.patch.dict(os.environ, {'baggage':'key1=value1,key2=value2'}) + def test_extract_context_when_baggage_is_valid_but_w3c_and_b3_spanid_are_invalid(self): + extracted_context = self.composite_env_propagator_obj.extract_context() + self.assertEqual(baggage.get_all(extracted_context) , {'key1':'value1','key2':'value2'}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + + @mock.patch.dict(os.environ, {'b3':'98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-98fea4de58eca772-136eec09c948be26-01'}) + @mock.patch.dict(os.environ, {'baggage':'key1=value1,key2=value2'}) + def test_extract_context_when_baggage_is_valid_and_traceid_of_b3_and_w3c_have_16_hex_char(self): + extracted_context = self.composite_env_propagator_obj.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '000000000000000098fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertEqual(val1 , "value1") + self.assertEqual(val2 , "value2") + + + @mock.patch.dict(os.environ, {'b3':'8128c50-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50-136eec09c948be26-01'}) + def test_extract_context_when_w3c_and_b3_traceid_is_invalid(self): + extracted_context = self.composite_env_propagator_b3_w3c_obj.extract_context() + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50f-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50f-136eec09c-01'}) + def test_extract_context_when_w3c_and_b3_traceid_and_spanid_are_invalid(self): + extracted_context = self.composite_env_propagator_b3_w3c_obj.extract_context() + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01'}) + @mock.patch.dict(os.environ, {'baggage':'key1=value1,=value2'}) + def test_extract_context_when_baggage_formatter_is_not_passed_to_propagator(self): + extracted_context = self.composite_env_propagator_b3_w3c_obj.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertIsNone(val1) + self.assertIsNone(val2) + + # Test cases for extract + + def test_extract_when_no_trace_details(self): + extracted_context = self.composite_env_propagator_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01'}) + @mock.patch.dict(os.environ, {'baggage':'key1=value1,=value2'}) + def test_extract_when_all_3_formats_are_valid(self): + extracted_context = self.composite_env_propagator_obj.extract(getter = getter, carrier = os.environ) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertEqual(val1 , "value1") + self.assertIsNone(val2) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01'}) + @mock.patch.dict(os.environ, {'baggage':'/value1'}) + def test_extract_when_w3c_and_b3_formats_are_valid_and_baggage_invalid(self): + extracted_context = self.composite_env_propagator_obj.extract(getter = getter, carrier = os.environ) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid,'8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid,'136eec09c948be26') + self.assertEqual(sampled, 1) + val = baggage.get_all(extracted_context) + self.assertEqual(val, {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c-01'}) + @mock.patch.dict(os.environ, {'baggage':'key1=value1,key2=value2'}) + def test_extract_when_baggage_is_valid_but_w3c_and_b3_spanid_are_invalid(self): + extracted_context = self.composite_env_propagator_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(baggage.get_all(extracted_context), {'key1':'value1', 'key2':'value2'}) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertEqual(val1,"value1") + self.assertEqual(val2,"value2") + + @mock.patch.dict(os.environ, {'b3':'98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-98fea4de58eca772-136eec09c948be26-01'}) + @mock.patch.dict(os.environ, {'baggage':'key1=value1,key2=value2'}) + def test_extract_when_baggage_is_valid_and_traceid_of_b3_and_w3c_have_16_hex_char(self): + extracted_context = self.composite_env_propagator_obj.extract(getter = getter, carrier = os.environ) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid, '000000000000000098fea4de58eca772') + self.assertEqual(spanid, '136eec09c948be26') + self.assertEqual(sampled, 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertEqual(val1, "value1") + self.assertEqual(val2, "value2") + + @mock.patch.dict(os.environ, {'baggage':'example1-value1;example2-value2'}) + def test_extract_baggage_invalid_format(self): + extracted_context = self.composite_env_propagator_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context, {}) + + @mock.patch.dict(os.environ, {'baggage':'example1=value1%2Cvalue2,example2=value3%2Cvalue4'}) + def test_extract_when_baggage_with_valid_format_has_commas_in_values(self): + extracted_context = self.composite_env_propagator_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(baggage.get_all(extracted_context) , {'example1':'value1,value2', 'example2':'value3,value4'}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + @mock.patch.dict(os.environ, {'b3':'8128c50f-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50f-136eec09c948be26-01'}) + def test_extract_when_traceid_is_invalid_for_w3c_and_b3(self): + extracted_context = self.composite_env_propagator_b3_w3c_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context, {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50f-136eec09c-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50f-136eec09c-01'}) + def test_extract_when_traceid_and_spanid_are_invalid_for_w3c_and_b3(self): + extracted_context = self.composite_env_propagator_b3_w3c_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context, {}) + + @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01'}) + @mock.patch.dict(os.environ, {'baggage':'key1=value1,=value2'}) + def test_extract_when_baggage_object_is_not_passed_to_propagator(self): + extracted_context = self.composite_env_propagator_b3_w3c_obj.extract(getter = getter, carrier = os.environ) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid, '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid, '136eec09c948be26') + self.assertEqual(sampled, 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertIsNone(val1) + self.assertIsNone(val2) diff --git a/propagator/opentelemetry-propagator-env/tests/test_tracecontext_baggage_composite_env_propagator.py b/propagator/opentelemetry-propagator-env/tests/test_tracecontext_baggage_composite_env_propagator.py new file mode 100644 index 00000000000..944c89cc02c --- /dev/null +++ b/propagator/opentelemetry-propagator-env/tests/test_tracecontext_baggage_composite_env_propagator.py @@ -0,0 +1,477 @@ +# 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 os +import unittest +from unittest import mock + +import opentelemetry +from opentelemetry import baggage +from opentelemetry.propagators.textmap import DefaultGetter, DefaultSetter +from opentelemetry.propagators.env.composite_propagator import CompositeEnvPropagator +from opentelemetry.trace.propagation import tracecontext +from opentelemetry.baggage.propagation import W3CBaggagePropagator +from tests.utils import * + +getter = DefaultGetter() + +class TestTracecontextBaggageCompositeEnvPropagator(unittest.TestCase): + def setUp(self): + self.mock_carrier = {} + self.composite_env_propagator_baggage_w3c_object = CompositeEnvPropagator([tracecontext.TraceContextTextMapPropagator(), W3CBaggagePropagator()]) + self.composite_env_propagator_None_object = CompositeEnvPropagator(None) + self.w3c_object = tracecontext.TraceContextTextMapPropagator() + + # test cases for inject_to_carrier for w3c and baggage + + def test_inject_to_carrier_when_valid_context_with_baggage_attached_for_w3c_and_baggage(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_baggage_w3c_object.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + + def test_inject_to_carrier_when_invalid_context_with_baggage_attached_for_w3c_and_baggage(self): + current_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(current_context) + self.mock_carrier = self.composite_env_propagator_baggage_w3c_object.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + + def test_inject_to_carrier_when_valid_context_with_baggage_passed_as_param_for_w3c_and_baggage(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_baggage_w3c_object.inject_to_carrier(context = dummy_context) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + + def test_inject_to_carrier_when_valid_context_without_baggage_passed_as_param_for_w3c_and_baggage(self): + dummy_context = create_dummy_context_with_parent_span() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_baggage_w3c_object.inject_to_carrier(context = dummy_context) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + + def test_inject_to_carrier_when_invalid_context_with_baggage_passed_as_param_for_w3c_and_baggage(self): + dummy_context = create_invalid_context_with_baggage() + self.mock_carrier = self.composite_env_propagator_baggage_w3c_object.inject_to_carrier(context = dummy_context) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + + def test_inject_to_carrier_when_None_object_passed_to_propagator_and_valid_context_attached_for_w3c_and_baggage(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_None_object.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_None_object_passed_to_propagator_and_invalid_context_attached_for_w3c_and_baggage(self): + dummy_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_None_object.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_None_object_passed_to_propagator_and_valid_context_passed_as_param_for_w3c_and_baggage(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_None_object.inject_to_carrier(context = dummy_context) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_None_object_passed_to_propagator_and_invalid_context_passed_as_param_for_w3c_and_baggage(self): + dummy_context = create_invalid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_None_object.inject_to_carrier(context = dummy_context) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_None_object_passed_to_propagator_and_None_context_passed_as_param_for_w3c_and_baggage(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_None_object.inject_to_carrier(None) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_None_object_passed_to_propagator_and_valid_context_without_baggage_attached_for_w3c_and_baggage(self): + dummy_context = create_dummy_context_with_parent_span() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_None_object.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_to_carrier_when_context_attached_and_context_passed_as_param_are_different_for_w3c_and_baggage(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_valid_context_with_baggage2() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_baggage_w3c_object.inject_to_carrier(context_passed) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertNotEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid2)+'-'+str(spanid2)+'-'+'0'+str(sampled2)) + self.assertEqual(self.mock_carrier.get("baggage") , "key3=1,key4=2") + self.assertNotEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + + # Test cases for inject + + def test_inject_when_None_object_passed_to_propagator_and_valid_context_with_baggage_attached(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_None_object_passed_to_propagator_and_invalid_context_with_baggage_attached(self): + dummy_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_None_object_passed_to_propagator_and_valid_context_with_baggage_passed_as_param(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_None_object_passed_to_propagator_and_invalid_context_with_baggage_passed_as_param(self): + dummy_context = create_invalid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_None_object_passed_to_propagator_and_None_context_passed_as_param(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_object.inject(carrier = self.mock_carrier, context = None, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_None_object_passed_to_propagator_and_valid_context_without_baggage_attached(self): + dummy_context = create_dummy_context_with_parent_span() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_None_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_valid_context_without_baggage_attached(self): + dummy_context = create_dummy_context_with_parent_span() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_baggage_w3c_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_invalid_context_without_baggage_attached(self): + dummy_context = create_invalid_context() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_baggage_w3c_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_valid_context_with_baggage_attached(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_baggage_w3c_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_invalid_context_with_baggage_attached(self): + dummy_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_baggage_w3c_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_valid_context_without_baggage_passed_as_param(self): + dummy_context = create_dummy_context_with_parent_span() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_baggage_w3c_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_invalid_context_with_no_baggage_passed_as_param(self): + dummy_context = create_invalid_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_baggage_w3c_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("baggage")) + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_valid_context_with_baggage_passed_as_param(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_baggage_w3c_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_invalid_context_with_baggage_passed_as_param(self): + dummy_context = create_invalid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_baggage_w3c_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") + self.assertIsNone(self.mock_carrier.get("b3")) + + def test_inject_when_context_attached_and_context_passed_as_param_with_baggage_are_different(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_valid_context_with_baggage2() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(dummy_context) + self.composite_env_propagator_baggage_w3c_object.inject(carrier = self.mock_carrier, context = context_passed, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertEqual(self.mock_carrier.get("baggage") , "key3=1,key4=2") + + def test_inject_when_context_attached_and_context_passed_as_param_without_baggage_are_different(self): + dummy_context = create_dummy_context() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_dummy_context2() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(dummy_context) + self.composite_env_propagator_baggage_w3c_object.inject(carrier = self.mock_carrier, context = context_passed, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertIsNone(self.mock_carrier.get("baggage")) + + def test_inject_when_traceid_has_16_hex_char(self): + dummy_context = create_dummy_context3() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.composite_env_propagator_baggage_w3c_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("baggage")) + + # Test cases for extract + + def test_extract_when_no_trace_details(self): + extracted_context = self.composite_env_propagator_baggage_w3c_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"b3": "8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,=value2"}) + def test_extract_when_w3c_and_baggage_are_valid(self): + extracted_context = self.composite_env_propagator_baggage_w3c_object.extract(getter = getter, carrier = os.environ) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertEqual(val1 , "value1") + self.assertIsNone(val2) + + @mock.patch.dict(os.environ, {"b3": "8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "=value1"}) + def test_extract_when_w3c_format_is_valid_and_baggage_invalid(self): + extracted_context = self.composite_env_propagator_baggage_w3c_object.extract(getter = getter, carrier = os.environ) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val = baggage.get_baggage("key1", extracted_context) + self.assertIsNone(val) + + @mock.patch.dict(os.environ, {"b3": "8128c50fd8653b5d98fea4de58eca772-136eec09c-1-e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,key2=value2"}) + def test_extract_when_baggage_is_valid_but_w3c_spanid_is_invalid(self): + extracted_context = self.composite_env_propagator_baggage_w3c_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(baggage.get_all(extracted_context) , {'key1': 'value1', 'key2': 'value2'}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + + @mock.patch.dict(os.environ, {"b3": "000000000000000098fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8fea4de58eca7724-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,key2=value2"}) + def test_extract_when_baggage_is_valid_and_traceid_of_w3c_has_16_hex_char(self): + extracted_context = self.composite_env_propagator_baggage_w3c_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(baggage.get_all(extracted_context) , {"key1":"value1", "key2":"value2"}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + @mock.patch.dict(os.environ, {"b3": "8128c50fd8653b5d98fea4de-136eec09c948be26-1-e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c5-136eec09c948be26-01"}) + def test_extract_when_w3c_traceid_is_invalid(self): + extracted_context = self.composite_env_propagator_baggage_w3c_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"b3": "8128c50fd8653b5d98fea4de-136eec09c-1-e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de-136eec09c-01"}) + def test_extract_when_w3c_traceid_and_spanid_are_invalid(self): + extracted_context = self.composite_env_propagator_baggage_w3c_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"b3": "8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + def test_extract_when_baggage_is_not_present_in_os_environ(self): + extracted_context = self.composite_env_propagator_baggage_w3c_object.extract(getter = getter, carrier = os.environ) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertIsNone(val1) + self.assertIsNone(val2) + + @mock.patch.dict(os.environ, {"baggage": "example1-value1;example2-value2"}) + def test_extract_baggage_invalid_format(self): + extracted_context = self.composite_env_propagator_baggage_w3c_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"baggage": "example1=value1%2Cvalue2,example2=value3%2Cvalue4"}) + def test_extract_when_baggage_with_valid_format_has_commas_in_values(self): + extracted_context = self.composite_env_propagator_baggage_w3c_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(baggage.get_all(extracted_context) , {'example1':'value1,value2','example2':'value3,value4'}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + + # test cases for extract_context + + def test_extract_context_when_no_trace_details(self): + extracted_context = self.composite_env_propagator_baggage_w3c_object.extract_context() + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"b3": "8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,=value2"}) + def test_extract_context_when_w3c_and_baggage_are_valid(self): + extracted_context = self.composite_env_propagator_baggage_w3c_object.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertEqual(val1 , "value1") + self.assertIsNone(val2) + + @mock.patch.dict(os.environ, {"b3": "8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "=value1"}) + def test_extract_context_when_w3c_format_is_valid_and_baggage_invalid(self): + extracted_context = self.composite_env_propagator_baggage_w3c_object.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val = baggage.get_baggage("key1", extracted_context) + self.assertIsNone(val) + + + @mock.patch.dict(os.environ, {"b3": "8128c50fd8653b5d98fea4de58eca772-136eec09c-1-e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,key2=value2"}) + def test_extract_context_when_baggage_is_valid_but_w3c_spanid_is_invalid(self): + extracted_context = self.composite_env_propagator_baggage_w3c_object.extract_context() + self.assertEqual(baggage.get_all(extracted_context),{'key1': 'value1', 'key2': 'value2'}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + + @mock.patch.dict(os.environ, {"b3": "98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,key2=value2"}) + def test_extract_context_when_baggage_is_valid_and_traceid_of_w3c_has_16_hex_char(self): + extracted_context = self.composite_env_propagator_baggage_w3c_object.extract_context() + self.assertEqual(baggage.get_all(extracted_context),{'key1': 'value1', 'key2': 'value2'}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + + @mock.patch.dict(os.environ, {"b3": "8128c50fd8653b5d98fea4de-136eec09c948be26-1-e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de-136eec09c948be26-01"}) + def test_extract_context_when_w3c_traceid_is_invalid(self): + extracted_context = self.composite_env_propagator_baggage_w3c_object.extract_context() + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"b3": "8128c50fd8653b5d98fea4de-136eec09c-1-e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de-136eec09c-01"}) + def test_extract_context_when_w3c_traceid_and_spanid_are_invalid(self): + extracted_context = self.composite_env_propagator_baggage_w3c_object.extract_context() + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"b3": "8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + def test_extract_context_when_baggage_is_not_present_os_environ(self): + extracted_context = self.composite_env_propagator_baggage_w3c_object.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertIsNone(val1) + self.assertIsNone(val2) + + @mock.patch.dict(os.environ, {"baggage": "example1-value1;example2-value2"}) + def test_extract_context_baggage_invalid_format(self): + extracted_context = self.composite_env_propagator_baggage_w3c_object.extract_context() + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"baggage": "example1=value1%2Cvalue2,example2=value3%2Cvalue4"}) + def test_extract_context_when_baggage_with_valid_format_has_commas_in_values(self): + extracted_context = self.composite_env_propagator_baggage_w3c_object.extract_context() + self.assertEqual(baggage.get_all(extracted_context) , {'example1': 'value1,value2', 'example2': 'value3,value4'}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) diff --git a/propagator/opentelemetry-propagator-env/tests/test_tracecontext_composite_env_propagator.py b/propagator/opentelemetry-propagator-env/tests/test_tracecontext_composite_env_propagator.py new file mode 100644 index 00000000000..d2302bb1fd8 --- /dev/null +++ b/propagator/opentelemetry-propagator-env/tests/test_tracecontext_composite_env_propagator.py @@ -0,0 +1,189 @@ +# 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 os +import unittest +from unittest import mock + +import opentelemetry +from opentelemetry.propagators.textmap import DefaultGetter, DefaultSetter +from opentelemetry.propagators.env.composite_propagator import CompositeEnvPropagator +from opentelemetry.trace.propagation import tracecontext +from tests.utils import * + +getter = DefaultGetter() + +class TestTracecontextCompositeEnvPropagator(unittest.TestCase): + def setUp(self): + self.mock_carrier = {} + self.composite_env_propagator_w3c_obj = CompositeEnvPropagator([tracecontext.TraceContextTextMapPropagator()]) + self.composite_env_propagator_None_obj = CompositeEnvPropagator(None) + self.w3c_object = tracecontext.TraceContextTextMapPropagator() + + # Test cases for inject_to_carrier + + def test_inject_to_carrier_when_valid_context_with_baggage_attached_for_w3c(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_w3c_obj.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertIsNone(self.mock_carrier.get("baggage")) + + def test_inject_to_carrier_when_invalid_context_with_baggage_attached_for_w3c(self): + current_context = create_invalid_context_with_baggage() + token = opentelemetry.context.attach(current_context) + self.mock_carrier = self.composite_env_propagator_w3c_obj.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertIsNone(self.mock_carrier.get("baggage")) + + def test_inject_to_carrier_when_valid_context_with_baggage_passed_as_param_for_w3c(self): + dummy_context = create_valid_context_with_baggage() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_w3c_obj.inject_to_carrier(context = dummy_context) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertIsNone(self.mock_carrier.get("baggage")) + + def test_inject_to_carrier_when_valid_context_without_baggage_passed_as_param_for_w3c(self): + dummy_context = create_dummy_context_with_parent_span() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_w3c_obj.inject_to_carrier(context = dummy_context) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertIsNone(self.mock_carrier.get("baggage")) + + def test_inject_to_carrier_with_invalid_context_with_baggage_passed_as_param_for_w3c(self): + dummy_context = create_invalid_context_with_baggage() + self.mock_carrier = self.composite_env_propagator_w3c_obj.inject_to_carrier(context = dummy_context) + self.assertIsNone(self.mock_carrier.get("traceparent")) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertIsNone(self.mock_carrier.get("baggage")) + + + def test_inject_to_carrier_when_context_attached_and_context_passed_as_param_are_different_for_w3c(self): + dummy_context = create_valid_context_with_baggage() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_valid_context_with_baggage2() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(dummy_context) + self.mock_carrier = self.composite_env_propagator_w3c_obj.inject_to_carrier(context_passed) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("b3")) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertNotEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid2)+'-'+str(spanid2)+'-'+'0'+str(sampled2)) + self.assertIsNone(self.mock_carrier.get("baggage")) + + ## Test cases for inject + + def test_inject_w3cformat_invalid_context_passed_as_param(self): + test_context = create_invalid_context() + self.composite_env_propagator_w3c_obj.inject(carrier = self.mock_carrier, context = test_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + + def test_inject_w3cformat_valid_context_passed_as_param(self): + test_context = create_dummy_context_with_parent_span() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + self.composite_env_propagator_w3c_obj.inject(carrier = self.mock_carrier, context = test_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier.get("traceparent") , "00"+"-"+str(trace_id)+"-"+str(span_id)+"-"+"0"+str(int(sampled_flag))) + + def test_inject_w3cformat_valid_context_attached(self): + test_context = create_dummy_context() + token = opentelemetry.context.attach(test_context) + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + self.composite_env_propagator_w3c_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , "00"+"-"+str(trace_id)+"-"+str(span_id)+"-"+"0"+str(int(sampled_flag))) + + def test_inject_w3cformat_invalid_context_attached(self): + test_context = create_invalid_context() + token = opentelemetry.context.attach(test_context) + self.composite_env_propagator_w3c_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + + def test_inject_w3cformat_when_context_attached_and_context_passed_as_param_are_different(self): + dummy_context = create_dummy_context2() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_dummy_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(dummy_context) + self.composite_env_propagator_w3c_obj.inject(carrier = self.mock_carrier, context = context_passed, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + + + # Test cases for extract + + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + def test_extract_valid_w3cformat_present_in_environment_variable(self): + extracted_context = self.composite_env_propagator_w3c_obj.extract(getter = getter, carrier = os.environ) + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(extracted_context) + self.assertEqual(trace_id , "8128c50fd8653b5d98fea4de58eca772") + self.assertEqual(span_id , "136eec09c948be26") + self.assertEqual(sampled_flag , 1) + self.assertEqual(tracestate , {}) + + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec06-a"}) + def test_extract_w3cformat_with_invalid_span_id(self): + extracted_context = self.composite_env_propagator_w3c_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50ed865ca77-136eec06ae45ae57-1"}) + def test_extract_w3cformat_with_invalid_trace_id_having_16_hex_char(self): + extracted_context = self.composite_env_propagator_w3c_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual( extracted_context , {}) + + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd865ca77-136eec06-1"}) + def test_extract_w3cformat_with_invalid_trace_id_and_span_id(self): + extracted_context = self.composite_env_propagator_w3c_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + def test_extract_when_no_trace_details_in_w3c_format(self): + extracted_context = self.composite_env_propagator_w3c_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + # test cases for extract_context + + def test_extract_context_when_no_trace_details(self): + extracted_context = self.composite_env_propagator_w3c_obj.extract_context() + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + def test_extract_context_valid_w3cformat_in_environment_variable(self): + extracted_context = self.composite_env_propagator_w3c_obj.extract_context() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(extracted_context) + self.assertEqual(trace_id , "8128c50fd8653b5d98fea4de58eca772") + self.assertEqual(span_id , "136eec09c948be26") + self.assertEqual(sampled_flag , 1) + self.assertEqual(tracestate , {}) + + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec06-a"}) + def test_extract_context_w3cformat_with_invalid_span_id(self): + extracted_context = self.composite_env_propagator_w3c_obj.extract_context() + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50ed865ca77-136eec06ae45ae57-1"}) + def test_extract_context_w3cformat_with_invalid_trace_id_having_16_hex_char(self): + extracted_context = self.composite_env_propagator_w3c_obj.extract_context() + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd865ca77-136eec06-1"}) + def test_extract_context_w3cformat_with_invalid_trace_id_and_span_id(self): + extracted_context = self.composite_env_propagator_w3c_obj.extract_context() + self.assertEqual(extracted_context , {}) diff --git a/propagator/opentelemetry-propagator-env/tests/test_tracecontext_env_propagator.py b/propagator/opentelemetry-propagator-env/tests/test_tracecontext_env_propagator.py new file mode 100644 index 00000000000..2e9503bc50c --- /dev/null +++ b/propagator/opentelemetry-propagator-env/tests/test_tracecontext_env_propagator.py @@ -0,0 +1,211 @@ +# 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 os +import unittest +from unittest import mock + +import opentelemetry +from opentelemetry.propagators.env import EnvPropagator +from opentelemetry.trace.propagation import tracecontext +from opentelemetry.propagators.textmap import DefaultGetter, DefaultSetter + +from tests.utils import create_invalid_context, create_dummy_context, get_details_from_context, create_dummy_context2,create_dummy_context3,create_dummy_context_with_parent_span + +getter = DefaultGetter() + +class TestTracecontextEnvPropagator(unittest.TestCase): + def setUp(self): + self.mock_carrier = {} + self.env_propagator_w3c_obj = EnvPropagator(tracecontext.TraceContextTextMapPropagator()) + self.env_propagator_None_obj = EnvPropagator(None) + self.w3c_object = tracecontext.TraceContextTextMapPropagator() + + # Test cases for inject_to_carrier + + def test_inject_to_carrier_when_context_attached_has_invalid_span_context(self): + current_context = create_invalid_context() + token = opentelemetry.context.attach(current_context) + + env_w3c = self.env_propagator_w3c_obj.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertEqual(env_w3c.get("traceparent") , None) + self.assertEqual(env_w3c.get("b3") , None) + + ## test cases for inject_to_carrier when None object passed to propagator + + def test_when_None_object_passed_to_env_propagator_and_context_attached(self): + dummy_context = create_dummy_context() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + + env_None = self.env_propagator_None_obj.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertEqual(env_None.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + + + def test_when_None_object_passed_to_env_propagator_and_context_passed_as_param(self): + dummy_context = create_dummy_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + + env_None = self.env_propagator_None_obj.inject_to_carrier(dummy_context) + self.assertEqual(env_None.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + + ## other test cases for inject_to_carrier + + def test_inject_to_carrier_when_attached_context_has_valid_span_context(self): + dummy_context = create_dummy_context() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) + + env_w3c = self.env_propagator_w3c_obj.inject_to_carrier() + opentelemetry.context.detach(token) + self.assertEqual(env_w3c.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(env_w3c.get("b3") , None) + + def test_inject_to_carrier_when_context_passed_is_None(self): + dummy_context = create_dummy_context() + token = opentelemetry.context.attach(dummy_context) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(None) + + env_w3c = self.env_propagator_w3c_obj.inject_to_carrier(None) + opentelemetry.context.detach(token) + self.assertEqual(env_w3c.get("traceparent"), '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(env_w3c.get("b3") , None) + + def test_inject_to_carrier_when_valid_context_is_passed_as_param(self): + context_passed = create_dummy_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + + env_w3c = self.env_propagator_w3c_obj.inject_to_carrier(context_passed) + self.assertEqual(env_w3c.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertEqual(env_w3c.get("b3") , None) + + def test_inject_to_carrier_when_attached_context_and_context_passed_as_param_are_different(self): + dummy_context = create_dummy_context2() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_dummy_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(dummy_context) + env_w3c = self.env_propagator_w3c_obj.inject_to_carrier(context_passed) + opentelemetry.context.detach(token) + self.assertEqual(env_w3c.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + self.assertNotEqual(env_w3c.get("traceparent") , '00'+'-'+str(traceid2)+'-'+str(spanid2)+'-'+'0'+str(sampled2)) + self.assertEqual(env_w3c.get("b3") , None) + + + ## Test cases for extract_context + + def test_extract_context_when_no_trace_details_in_w3c_format(self): + extracted_context_w3c = self.env_propagator_w3c_obj.extract_context() + self.assertEqual(extracted_context_w3c , {}) + + @mock.patch.dict(os.environ, {'traceparent': '00-123-136eec09c948be26-1'}) + def test_extract_context_when_traceid_format_does_not_match_regex_for_w3c(self): + extracted_context = self.env_propagator_w3c_obj.extract_context() + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {'traceparent': '00-8128c50fd8653b5d98fea4de58eca772-136e-1'}) + def test_extract_context_when_spanid_format_does_not_match_regex_for_w3c(self): + extracted_context = self.env_propagator_w3c_obj.extract_context() + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {'traceparent': '00-123-136-1'}) + def test_extract_context_when_traceid_and_spanid_format_do_not_match_regex_for_w3c(self): + extracted_context = self.env_propagator_w3c_obj.extract_context() + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {'traceparent': '00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01'}) + @mock.patch.dict(os.environ, {'tracestate': 'congo=t61rcWkgMzE'}) + def test_extract_context_when_w3c_valid_format_has_tracestate(self): + extracted_context = self.env_propagator_w3c_obj.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + self.assertEqual(tracestate , {'congo':'t61rcWkgMzE'}) + + + ## Test cases for inject + + def test_inject_w3cformat_invalid_context_passed_as_param(self): + test_context = create_invalid_context() + self.env_propagator_w3c_obj.inject(carrier = self.mock_carrier, context = test_context, setter = DefaultSetter()) + self.assertIsNone(self.mock_carrier.get("traceparent")) + + def test_inject_w3cformat_valid_context_passed_as_param(self): + test_context = create_dummy_context_with_parent_span() + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + self.env_propagator_w3c_obj.inject(carrier = self.mock_carrier, context = test_context, setter = DefaultSetter()) + self.assertEqual(self.mock_carrier["traceparent"] , "00"+"-"+str(trace_id)+"-"+str(span_id)+"-"+"0"+str(int(sampled_flag))) + + def test_inject_w3cformat_valid_context_attached(self): + test_context = create_dummy_context() + token = opentelemetry.context.attach(test_context) + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(test_context) + self.env_propagator_w3c_obj.inject(carrier = self.mock_carrier, context = test_context, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier["traceparent"] , "00"+"-"+str(trace_id)+"-"+str(span_id)+"-"+"0"+str(int(sampled_flag))) + + def test_inject_w3cformat_invalid_context_attached(self): + test_context = create_invalid_context() + token = opentelemetry.context.attach(test_context) + self.env_propagator_w3c_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertIsNone(self.mock_carrier.get("traceparent")) + + def test_inject_w3cformat_when_context_attached_and_context_passed_as_param_are_different(self): + dummy_context = create_dummy_context2() + token = opentelemetry.context.attach(dummy_context) + context_passed = create_dummy_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(context_passed) + traceid2, spanid2, sampled2, parentspanid2, tracestate2 = get_details_from_context(dummy_context) + self.env_propagator_w3c_obj.inject(carrier = self.mock_carrier, context = context_passed, setter = DefaultSetter()) + opentelemetry.context.detach(token) + self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) + + ## Test cases for extract + + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) + def test_extract_when_valid_w3cformat_in_environment_variable(self): + extracted_context = self.env_propagator_w3c_obj.extract(getter = getter, carrier = os.environ) + trace_id, span_id, sampled_flag, parent_span_id, tracestate = get_details_from_context(extracted_context) + self.assertEqual(trace_id , "8128c50fd8653b5d98fea4de58eca772") + self.assertEqual(span_id , "136eec09c948be26") + self.assertEqual(sampled_flag , 1) + self.assertEqual(tracestate , {}) + + @mock.patch.dict(os.environ, {"traceparent": "00-8128ca772-136eec06-01"}) + def test_extract_when_invalid_w3cformat_in_environment_variable(self): + extracted_context = self.env_propagator_w3c_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec06-01"}) + def test_extract_w3cformat_with_invalid_span_id(self): + extracted_context = self.env_propagator_w3c_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d-136eec06ae45ae57-01"}) + def test_extract_w3cformat_with_trace_id_having_16_hex_char(self): + extracted_context = self.env_propagator_w3c_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd865ca77-136eec06-01"}) + def test_extract_w3cformat_with_invalid_trace_id_and_span_id(self): + extracted_context = self.env_propagator_w3c_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) + + def test_extract_when_no_trace_details_in_w3c_format(self): + extracted_context = self.env_propagator_w3c_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(extracted_context , {}) diff --git a/propagator/opentelemetry-propagator-env/tests/utils.py b/propagator/opentelemetry-propagator-env/tests/utils.py new file mode 100644 index 00000000000..8ec134268bd --- /dev/null +++ b/propagator/opentelemetry-propagator-env/tests/utils.py @@ -0,0 +1,121 @@ +import opentelemetry +from opentelemetry import trace +from opentelemetry.sdk.trace import TracerProvider +from opentelemetry.trace.span import NonRecordingSpan +from opentelemetry.trace.span import SpanContext +from opentelemetry.trace.span import format_span_id +from opentelemetry.trace.span import format_trace_id +from opentelemetry.baggage import _BAGGAGE_KEY +from opentelemetry.context import get_value, set_value + + +def create_dummy_context(): + trace_id = 0x546a43e10e63d462df190eb91fccd21c + span_id = 0xa61596de7d07c857 + sampled = "0" + return opentelemetry.trace.propagation.set_span_in_context( + NonRecordingSpan( + SpanContext( + trace_id=trace_id, + span_id=span_id, + is_remote=True, + trace_flags=trace.TraceFlags(0), + trace_state=trace.TraceState(), + ) + ), + {} + ) + +def create_dummy_context2(): + trace_id = 0x899a43e10e63d462df190eb91fccd21c + span_id = 0xa89996de7d07c857 + sampled = "1" + return opentelemetry.trace.propagation.set_span_in_context( + NonRecordingSpan( + SpanContext( + trace_id=trace_id, + span_id=span_id, + is_remote=True, + trace_flags=trace.TraceFlags(0), + trace_state=trace.TraceState(), + ) + ), + {} + ) + +def create_dummy_context3(): + trace_id = 0x899a43e10e63d462 + span_id = 0xa89996de7d07c857 + sampled = "1" + return opentelemetry.trace.propagation.set_span_in_context( + NonRecordingSpan( + SpanContext( + trace_id=trace_id, + span_id=span_id, + is_remote=True, + trace_flags=trace.TraceFlags(0), + trace_state=trace.TraceState(), + ) + ), + {} + ) + +def create_dummy_context_with_parent_span(): + trace_id = 0x546a43e10e63d462df190eb91fccd21c + span_id = 0xa61596de7d07c857 + sampled = "0" + default_span = NonRecordingSpan( + SpanContext( + trace_id=trace_id, + span_id=span_id, + is_remote=True, + trace_flags=trace.TraceFlags(0), + trace_state=trace.TraceState(), + ) + ) + setattr(default_span, "parent", SpanContext(trace_id = trace_id, span_id = 0xca6f04b3f3de0b3d, is_remote = True)) + return opentelemetry.trace.propagation.set_span_in_context(default_span, {}) + + +def create_invalid_context(): + INVALID_SPAN_ID = 0x0000000000000000 + INVALID_TRACE_ID = 0x00000000000000000000000000000000 + sampled = "0" + INVALID_SPAN_CONTEXT = SpanContext( + trace_id=INVALID_TRACE_ID, + span_id=INVALID_SPAN_ID, + is_remote=False, + trace_flags=trace.TraceFlags(0), + trace_state=trace.TraceState(), + ) + INVALID_SPAN = NonRecordingSpan(INVALID_SPAN_CONTEXT) + return opentelemetry.trace.propagation.set_span_in_context(INVALID_SPAN, {}) + +def create_invalid_context_with_baggage(): + dummy_context = create_invalid_context() + return set_value(_BAGGAGE_KEY, {"test1":1, "test2":2}, context=dummy_context) + +def create_valid_context_with_baggage(): + dummy_context = create_dummy_context() + return set_value(_BAGGAGE_KEY, {"key1":1, "key2":2}, context=dummy_context) + +def create_valid_context_with_baggage2(): + dummy_context = create_dummy_context2() + return set_value(_BAGGAGE_KEY, {"key3":1, "key4":2}, context=dummy_context) + + +def get_details_from_context(context): + span = trace.get_current_span(context) + if span is None: + return span + span_parent = getattr(span, "parent", None) + span_context = span.get_span_context() + trace_id = format_trace_id(span_context.trace_id) + span_id = format_span_id(span_context.span_id) + sampled = span_context.trace_flags + tracestate = span_context.trace_state + if span_parent: + parent_span_id = format_span_id(span_parent.span_id) + else: + parent_span_id = None + return trace_id, span_id, sampled, parent_span_id, tracestate From 5815a7b13b5351ca3b586d579fc0ea147c721e9b Mon Sep 17 00:00:00 2001 From: Divya Sharma Date: Tue, 7 Sep 2021 14:09:50 -0700 Subject: [PATCH 2/6] chore(tests): modify utils file to remove import statement for TracerProvider --- propagator/opentelemetry-propagator-env/tests/utils.py | 1 - 1 file changed, 1 deletion(-) diff --git a/propagator/opentelemetry-propagator-env/tests/utils.py b/propagator/opentelemetry-propagator-env/tests/utils.py index 8ec134268bd..5e63bed0233 100644 --- a/propagator/opentelemetry-propagator-env/tests/utils.py +++ b/propagator/opentelemetry-propagator-env/tests/utils.py @@ -1,6 +1,5 @@ import opentelemetry from opentelemetry import trace -from opentelemetry.sdk.trace import TracerProvider from opentelemetry.trace.span import NonRecordingSpan from opentelemetry.trace.span import SpanContext from opentelemetry.trace.span import format_span_id From b48d1c2d317d59689d03f8129c6f68327f170182 Mon Sep 17 00:00:00 2001 From: Divya Sharma Date: Mon, 13 Sep 2021 15:55:29 -0700 Subject: [PATCH 3/6] chore(propagator): modify extract function and test cases --- .../propagators/env/composite_propagator.py | 5 +- .../propagators/env/propagator.py | 2 - ...format_baggage_composite_env_propagator.py | 1 - ...t_tracecontext_composite_env_propagator.py | 145 +++++++++++++----- ...t_tracecontext_composite_env_propagator.py | 134 +++++++++++----- ...ontext_baggage_composite_env_propagator.py | 18 +-- ...t_tracecontext_composite_env_propagator.py | 16 +- .../tests/test_tracecontext_env_propagator.py | 18 +-- 8 files changed, 228 insertions(+), 111 deletions(-) diff --git a/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/composite_propagator.py b/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/composite_propagator.py index 8eb1030ddab..6ea72aab844 100644 --- a/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/composite_propagator.py +++ b/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/composite_propagator.py @@ -40,10 +40,7 @@ def extract(self, carrier: CarrierT, context: typing.Optional[Context] = None, g self._propagators = [TraceContextTextMapPropagator(), W3CBaggagePropagator()] for propagator in self._propagators: - if isinstance(propagator, B3SingleFormat): - context = B3MultiFormat().extract(carrier, context, getter) - else: - context = propagator.extract(carrier, context, getter) + context = propagator.extract(carrier, context, getter) return context def inject(self, carrier: CarrierT, context: typing.Optional[Context] = None, setter: Setter = textmap.default_setter) -> None: diff --git a/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/propagator.py b/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/propagator.py index 08ae4765833..c72b22e334c 100644 --- a/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/propagator.py +++ b/propagator/opentelemetry-propagator-env/src/opentelemetry/propagators/env/propagator.py @@ -36,8 +36,6 @@ def __init__(self, formatter): # delegating to extract function implementation of the formatter def extract(self, carrier: CarrierT, context: typing.Optional[Context] = None, getter: Getter = DefaultGetter()) -> Context: - if isinstance(self.formatter, B3SingleFormat): - return B3MultiFormat().extract(carrier = carrier, context=context, getter = getter) return self.formatter.extract(carrier = carrier, context=context, getter = getter) # delegating to inject function implementation of the formatter diff --git a/propagator/opentelemetry-propagator-env/tests/test_b3_multi_format_baggage_composite_env_propagator.py b/propagator/opentelemetry-propagator-env/tests/test_b3_multi_format_baggage_composite_env_propagator.py index dbf9e2f3b3c..e77f437ee9c 100644 --- a/propagator/opentelemetry-propagator-env/tests/test_b3_multi_format_baggage_composite_env_propagator.py +++ b/propagator/opentelemetry-propagator-env/tests/test_b3_multi_format_baggage_composite_env_propagator.py @@ -412,7 +412,6 @@ def test_extract_when_b3_format_is_valid_and_baggage_invalid(self): @mock.patch.dict(os.environ, {"baggage": "key1=value1,key2=value2"}) def test_extract_when_baggage_is_valid_but_b3_spanid_is_invalid(self): extracted_context = self.composite_propagator_b3_baggage_object.extract(carrier = os.environ, getter = getter) - print("****extracted_context: ***", extracted_context) self.assertEqual(baggage.get_all(extracted_context), {'key1':'value1', 'key2':'value2'}) @mock.patch.dict(os.environ, {"x-b3-traceid": "98fea4de58eca772"}) diff --git a/propagator/opentelemetry-propagator-env/tests/test_b3_multi_format_tracecontext_composite_env_propagator.py b/propagator/opentelemetry-propagator-env/tests/test_b3_multi_format_tracecontext_composite_env_propagator.py index 041cadf6dbc..cf070a6b6bc 100644 --- a/propagator/opentelemetry-propagator-env/tests/test_b3_multi_format_tracecontext_composite_env_propagator.py +++ b/propagator/opentelemetry-propagator-env/tests/test_b3_multi_format_tracecontext_composite_env_propagator.py @@ -30,8 +30,11 @@ class TestB3MultiTraceContextEnvPropagator(unittest.TestCase): def setUp(self): self.mock_carrier = {} self.composite_env_propagator_b3_w3c_object = CompositeEnvPropagator([B3MultiFormat(), TraceContextTextMapPropagator()]) - self.composite_env_propagator_object = CompositeEnvPropagator([B3MultiFormat(), TraceContextTextMapPropagator(), W3CBaggagePropagator()]) + self.composite_env_propagator_w3c_b3_object = CompositeEnvPropagator([TraceContextTextMapPropagator(), B3MultiFormat()]) + self.composite_env_b3_w3c_baggage_propagator_object = CompositeEnvPropagator([B3MultiFormat(), TraceContextTextMapPropagator(), W3CBaggagePropagator()]) + self.composite_env_w3c_b3_baggage_propagator_object = CompositeEnvPropagator([TraceContextTextMapPropagator(), B3MultiFormat(), W3CBaggagePropagator()]) self.composite_env_propagator_None_object = CompositeEnvPropagator(None) + self.baggage_propagator_object = W3CBaggagePropagator() # Test cases for inject @@ -256,7 +259,7 @@ def test_inject_when_valid_context_with_baggage_attached_for_all_3_formats(self) dummy_context = create_valid_context_with_baggage() token = opentelemetry.context.attach(dummy_context) traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.composite_env_propagator_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + self.composite_env_b3_w3c_baggage_propagator_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) opentelemetry.context.detach(token) self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") @@ -270,7 +273,7 @@ def test_inject_when_valid_context_without_baggage_attached_for_all_3_formats(se dummy_context = create_dummy_context_with_parent_span() token = opentelemetry.context.attach(dummy_context) traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.composite_env_propagator_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + self.composite_env_b3_w3c_baggage_propagator_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) opentelemetry.context.detach(token) self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) self.assertIsNone(self.mock_carrier.get("baggage")) @@ -283,7 +286,7 @@ def test_inject_when_valid_context_without_baggage_attached_for_all_3_formats(se def test_inject_when_invalid_context_with_baggage_attached_for_all_3_formats(self): current_context = create_invalid_context_with_baggage() token = opentelemetry.context.attach(current_context) - self.composite_env_propagator_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + self.composite_env_b3_w3c_baggage_propagator_object.inject(carrier = self.mock_carrier, setter = DefaultSetter()) opentelemetry.context.detach(token) self.assertIsNone(self.mock_carrier.get("traceparent")) self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") @@ -296,7 +299,7 @@ def test_inject_when_invalid_context_with_baggage_attached_for_all_3_formats(sel def test_inject_when_valid_context_with_baggage_passed_for_all_3_formats(self): dummy_context = create_valid_context_with_baggage() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.composite_env_propagator_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.composite_env_b3_w3c_baggage_propagator_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) @@ -308,7 +311,7 @@ def test_inject_when_valid_context_with_baggage_passed_for_all_3_formats(self): def test_inject_when_valid_context_with_no_baggage_passed_for_all_3_formats(self): dummy_context = create_dummy_context_with_parent_span() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.composite_env_propagator_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.composite_env_b3_w3c_baggage_propagator_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) self.assertIsNone(self.mock_carrier.get("baggage")) self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) @@ -320,7 +323,7 @@ def test_inject_when_valid_context_with_no_baggage_passed_for_all_3_formats(self def test_inject_when_invalid_context_with_baggage_passed_for_all_3_formats(self): dummy_context = create_invalid_context_with_baggage() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.composite_env_propagator_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.composite_env_b3_w3c_baggage_propagator_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) self.assertIsNone(self.mock_carrier.get("traceparent")) self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") self.assertIsNone(self.mock_carrier.get("x-b3-traceid") ) @@ -332,7 +335,7 @@ def test_inject_when_invalid_context_with_baggage_passed_for_all_3_formats(self) def test_inject_when_traceid_has_16_hex_char(self): dummy_context = create_dummy_context3() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.composite_env_propagator_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.composite_env_b3_w3c_baggage_propagator_object.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) @@ -483,7 +486,7 @@ def test_inject_to_carrier_when_valid_context_is_attached_for_all_3_formats(self dummy_context = create_valid_context_with_baggage() token = opentelemetry.context.attach(dummy_context) traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.mock_carrier = self.composite_env_propagator_object.inject_to_carrier() + self.mock_carrier = self.composite_env_b3_w3c_baggage_propagator_object.inject_to_carrier() opentelemetry.context.detach(token) self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") @@ -497,7 +500,7 @@ def test_inject_to_carrier_when_valid_context_without_baggage_is_attached_for_al dummy_context = create_dummy_context_with_parent_span() token = opentelemetry.context.attach(dummy_context) traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.mock_carrier = self.composite_env_propagator_object.inject_to_carrier() + self.mock_carrier = self.composite_env_b3_w3c_baggage_propagator_object.inject_to_carrier() opentelemetry.context.detach(token) self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) self.assertIsNone(self.mock_carrier.get("baggage")) @@ -510,7 +513,7 @@ def test_inject_to_carrier_when_valid_context_without_baggage_is_attached_for_al def test_inject_to_carrier_when_invalid_context_is_attached_for_all_3_formats(self): current_context = create_invalid_context_with_baggage() token = opentelemetry.context.attach(current_context) - self.mock_carrier = self.composite_env_propagator_object.inject_to_carrier() + self.mock_carrier = self.composite_env_b3_w3c_baggage_propagator_object.inject_to_carrier() opentelemetry.context.detach(token) self.assertIsNone(self.mock_carrier.get("traceparent")) self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") @@ -523,7 +526,7 @@ def test_inject_to_carrier_when_invalid_context_is_attached_for_all_3_formats(se def test_inject_to_carrier_when_valid_context_passed_as_param_for_all_3_formats(self): dummy_context = create_valid_context_with_baggage() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.mock_carrier = self.composite_env_propagator_object.inject_to_carrier(context = dummy_context) + self.mock_carrier = self.composite_env_b3_w3c_baggage_propagator_object.inject_to_carrier(context = dummy_context) self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) @@ -535,7 +538,7 @@ def test_inject_to_carrier_when_valid_context_passed_as_param_for_all_3_formats( def test_inject_to_carrier_when_valid_context_without_baggage_passed_as_param_for_all_3_formats(self): dummy_context = create_dummy_context_with_parent_span() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.mock_carrier = self.composite_env_propagator_object.inject_to_carrier(context = dummy_context) + self.mock_carrier = self.composite_env_b3_w3c_baggage_propagator_object.inject_to_carrier(context = dummy_context) self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) self.assertIsNone(self.mock_carrier.get("baggage")) self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) @@ -547,7 +550,7 @@ def test_inject_to_carrier_when_valid_context_without_baggage_passed_as_param_fo def test_inject_to_carrier_when_invalid_context_passed_as_param_for_all_3_formats(self): dummy_context = create_invalid_context_with_baggage() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.mock_carrier = self.composite_env_propagator_object.inject_to_carrier(context = dummy_context) + self.mock_carrier = self.composite_env_b3_w3c_baggage_propagator_object.inject_to_carrier(context = dummy_context) self.assertIsNone(self.mock_carrier.get("traceparent")) self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") self.assertIsNone(self.mock_carrier.get("x-b3-traceid")) @@ -559,7 +562,7 @@ def test_inject_to_carrier_when_invalid_context_passed_as_param_for_all_3_format def test_inject_to_carrier_when_traceid_has_16_hex_char(self): dummy_context = create_dummy_context3() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.mock_carrier = self.composite_env_propagator_object.inject_to_carrier(context = dummy_context) + self.mock_carrier = self.composite_env_b3_w3c_baggage_propagator_object.inject_to_carrier(context = dummy_context) self.assertEqual(self.mock_carrier.get("x-b3-traceid") , str(traceid)) self.assertEqual(self.mock_carrier.get("x-b3-spanid") , str(spanid)) self.assertEqual(self.mock_carrier.get("x-b3-sampled") , str(sampled)) @@ -571,8 +574,9 @@ def test_inject_to_carrier_when_traceid_has_16_hex_char(self): ## Test cases for extract_context def test_extract_context_when_no_trace_details(self): - extracted_context = self.composite_env_propagator_object.extract_context() - self.assertEqual(extracted_context , {}) + extracted_context = self.composite_env_b3_w3c_baggage_propagator_object.extract_context() + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) @@ -581,7 +585,7 @@ def test_extract_context_when_no_trace_details(self): @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) @mock.patch.dict(os.environ, {"baggage": "key1=value1,=value2"}) def test_extract_context_when_all_3_formats_are_valid(self): - extracted_context = self.composite_env_propagator_object.extract_context() + extracted_context = self.composite_env_b3_w3c_baggage_propagator_object.extract_context() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') self.assertEqual(spanid , '136eec09c948be26') @@ -599,7 +603,7 @@ def test_extract_context_when_all_3_formats_are_valid(self): @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) @mock.patch.dict(os.environ, {"baggage": "=value1"}) def test_extract_context_when_w3c_and_b3_formats_are_valid_and_baggage_invalid(self): - extracted_context = self.composite_env_propagator_object.extract_context() + extracted_context = self.composite_env_b3_w3c_baggage_propagator_object.extract_context() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') self.assertEqual(spanid , '136eec09c948be26') @@ -614,7 +618,7 @@ def test_extract_context_when_w3c_and_b3_formats_are_valid_and_baggage_invalid(s @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c-01"}) @mock.patch.dict(os.environ, {"baggage": "key1=value1,key2=value2"}) def test_extract_context_when_baggage_is_valid_but_w3c_and_b3_spanid_are_invalid(self): - extracted_context = self.composite_env_propagator_object.extract_context() + extracted_context = self.composite_env_b3_w3c_baggage_propagator_object.extract_context() self.assertEqual(baggage.get_all(extracted_context) , {'key1':'value1','key2':'value2'}) self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @@ -626,7 +630,23 @@ def test_extract_context_when_baggage_is_valid_but_w3c_and_b3_spanid_are_invalid @mock.patch.dict(os.environ, {"traceparent": "00-98fea4de58eca772-136eec09c948be26-01"}) @mock.patch.dict(os.environ, {"baggage": "key1=value1,key2=value2"}) def test_extract_context_when_baggage_is_valid_and_traceid_of_b3_and_w3c_have_16_hex_char(self): - extracted_context = self.composite_env_propagator_object.extract_context() + extracted_context = self.composite_env_b3_w3c_baggage_propagator_object.extract_context() + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertEqual(val1 , "value1") + self.assertEqual(val2 , "value2") + + + @mock.patch.dict(os.environ, {"x-b3-traceid": "98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,key2=value2"}) + def test_extract_context_when_baggage_is_valid_and_traceid_of_w3c_and_b3_have_16_hex_char(self): + # order of propagators in composite propagator: TraceContextTextMapPropagator, B3 + extracted_context = self.composite_env_w3c_b3_baggage_propagator_object.extract_context() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) self.assertEqual(traceid , '000000000000000098fea4de58eca772') self.assertEqual(spanid , '136eec09c948be26') @@ -636,6 +656,7 @@ def test_extract_context_when_baggage_is_valid_and_traceid_of_b3_and_w3c_have_16 self.assertEqual(val1 , "value1") self.assertEqual(val2 , "value2") + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50f"}) @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) @@ -643,7 +664,7 @@ def test_extract_context_when_baggage_is_valid_and_traceid_of_b3_and_w3c_have_16 @mock.patch.dict(os.environ, {"traceparent": "00-8128c50f-136eec09c948be26-01"}) def test_extract_context_when_w3c_and_b3_traceid_is_invalid(self): extracted_context = self.composite_env_propagator_b3_w3c_object.extract_context() - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50f"}) @@ -652,8 +673,21 @@ def test_extract_context_when_w3c_and_b3_traceid_is_invalid(self): @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) @mock.patch.dict(os.environ, {"traceparent": "00-8128c50f-136eec09c-01"}) def test_extract_context_when_w3c_and_b3_traceid_and_spanid_are_invalid(self): + # order of propagators in composite propagator: TraceContextTextMapPropagator, B3 + extracted_context = self.composite_env_propagator_w3c_b3_object.extract_context() + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50f"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50f-136eec09c-01"}) + def test_extract_context_when_b3_and_w3c_traceid_and_spanid_are_invalid(self): + # order of propagators in composite propagator: B3, TraceContextTextMapPropagator extracted_context = self.composite_env_propagator_b3_w3c_object.extract_context() - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) @@ -662,6 +696,7 @@ def test_extract_context_when_w3c_and_b3_traceid_and_spanid_are_invalid(self): @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) @mock.patch.dict(os.environ, {"baggage": "key1=value1,=value2"}) def test_extract_context_when_baggage_object_is_not_passed_to_the_propagator(self): + # order of propagators in composite propagator: B3, TraceContextTextMapPropagator extracted_context = self.composite_env_propagator_b3_w3c_object.extract_context() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') @@ -676,8 +711,8 @@ def test_extract_context_when_baggage_object_is_not_passed_to_the_propagator(sel ## Test cases for extract def test_extract_when_no_trace_details(self): - extracted_context = self.composite_env_propagator_object.extract(getter = getter, carrier = os.environ) - self.assertEqual(extracted_context , {}) + extracted_context = self.composite_env_b3_w3c_baggage_propagator_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) @@ -686,7 +721,7 @@ def test_extract_when_no_trace_details(self): @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) @mock.patch.dict(os.environ, {"baggage": "key1=value1,=value2"}) def test_extract_when_all_3_formats_are_valid(self): - extracted_context = self.composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + extracted_context = self.composite_env_b3_w3c_baggage_propagator_object.extract(getter = getter, carrier = os.environ) traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') self.assertEqual(spanid , '136eec09c948be26') @@ -703,7 +738,7 @@ def test_extract_when_all_3_formats_are_valid(self): @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) @mock.patch.dict(os.environ, {"baggage": "=value1"}) def test_extract_when_w3c_and_b3_formats_are_valid_and_baggage_invalid(self): - extracted_context = self.composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + extracted_context = self.composite_env_b3_w3c_baggage_propagator_object.extract(getter = getter, carrier = os.environ) traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') self.assertEqual(spanid , '136eec09c948be26') @@ -718,7 +753,7 @@ def test_extract_when_w3c_and_b3_formats_are_valid_and_baggage_invalid(self): @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c-01"}) @mock.patch.dict(os.environ, {"baggage": "key1=value1,key2=value2"}) def test_extract_when_baggage_is_valid_but_w3c_and_b3_spanid_are_invalid(self): - extracted_context = self.composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + extracted_context = self.composite_env_b3_w3c_baggage_propagator_object.extract(getter = getter, carrier = os.environ) self.assertEqual(baggage.get_all(extracted_context) , {'key1':'value1', 'key2':'value2'}) self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @@ -729,24 +764,43 @@ def test_extract_when_baggage_is_valid_but_w3c_and_b3_spanid_are_invalid(self): @mock.patch.dict(os.environ, {"traceparent": "00-98fea4de58eca772-136eec09c948be26-01"}) @mock.patch.dict(os.environ, {"baggage": "key1=value1,key2=value2"}) def test_extract_when_baggage_is_valid_and_traceid_of_b3_and_w3c_have_16_hex_char(self): - extracted_context = self.composite_env_propagator_object.extract(getter = getter, carrier = os.environ) - traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) - self.assertEqual(traceid , '000000000000000098fea4de58eca772') - self.assertEqual(spanid , '136eec09c948be26') - self.assertEqual(sampled , 1) + extracted_context = self.composite_env_b3_w3c_baggage_propagator_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) val1 = baggage.get_baggage("key1", extracted_context) val2 = baggage.get_baggage("key2", extracted_context) self.assertEqual(val1 , "value1") self.assertEqual(val2 , "value2") + + @mock.patch.dict(os.environ, {"x-b3-traceid": "98fea4de58eca772"}) + @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) + @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) + @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) + @mock.patch.dict(os.environ, {"traceparent": "00-98fea4de58eca772-136eec09c948be26-01"}) + @mock.patch.dict(os.environ, {"baggage": "key1=value1,key2=value2"}) + def test_extract_when_baggage_is_valid_and_traceid_of_w3c_and_b3_have_16_hex_char(self): + # order of propagators in composite propagator: TraceContextTextMapPropagator, B3 + extracted_context = self.composite_env_w3c_b3_baggage_propagator_object.extract(getter = getter, carrier = os.environ) + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '000000000000000098fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertEqual(val1 , "value1") + self.assertEqual(val2 , "value2") + + @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50f"}) @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) @mock.patch.dict(os.environ, {"x-b3-sampled": "1"}) @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) @mock.patch.dict(os.environ, {"traceparent": "00-8128c50f-136eec09c948be26-01"}) def test_extract_when_w3c_and_b3_traceid_is_invalid(self): + # order of propagators in composite propagator: B3, TraceContextTextMapPropagator extracted_context = self.composite_env_propagator_b3_w3c_object.extract(getter = getter, carrier = os.environ) - self.assertEqual(extracted_context , {}) + # current span is invalid as b3 returns invalid span in context + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50f-136eec09c"}) @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c"}) @@ -754,8 +808,10 @@ def test_extract_when_w3c_and_b3_traceid_is_invalid(self): @mock.patch.dict(os.environ, {"x-b3-parentspanid": "e28bf981e15deb7f"}) @mock.patch.dict(os.environ, {"traceparent": "00-8128c50f-136eec09c-01"}) def test_extract_when_w3c_and_b3_traceid_and_spanid_are_invalid(self): + # order of propagators in composite propagator: B3, TraceContextTextMapPropagator extracted_context = self.composite_env_propagator_b3_w3c_object.extract(getter = getter, carrier = os.environ) - self.assertEqual(extracted_context , {}) + # current span is invalid as b3 returns invalid span in context + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {"x-b3-traceid": "8128c50fd8653b5d98fea4de58eca772"}) @mock.patch.dict(os.environ, {"x-b3-spanid": "136eec09c948be26"}) @@ -776,12 +832,25 @@ def test_extract_when_baggage_object_is_not_passed_to_propagator(self): @mock.patch.dict(os.environ, {"baggage": "example1-value1;example2-value2"}) - def test_extract_when_baggage_format_invalid(self): - extracted_context = self.composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + def test_extract_when_baggage_format_invalid_and_b3_w3c_baggage_propagators_passed_to_composite_propagator(self): + # order of propagators in composite propagator: B3, TraceContextTextMapPropagator + extracted_context = self.composite_env_b3_w3c_baggage_propagator_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + @mock.patch.dict(os.environ, {"baggage": "example1-value1;example2-value2"}) + def test_extract_when_baggage_format_invalid_and_w3c_b3_baggage_propagators_passed_to_composite_propagator(self): + # order of propagators in composite propagator: TraceContextTextMapPropagator, B3 + extracted_context = self.composite_env_w3c_b3_baggage_propagator_object.extract(getter = getter, carrier = os.environ) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + @mock.patch.dict(os.environ, {"baggage": "example1-value1;example2-value2"}) + def test_extract_when_baggage_format_invalid_and_baggage_propagator_passed_to_composite_propagator(self): + extracted_context = self.baggage_propagator_object.extract(getter= getter, carrier = os.environ) self.assertEqual(extracted_context , {}) + @mock.patch.dict(os.environ, {"baggage": "example1=value1%2Cvalue2,example2=value3%2Cvalue4"}) def test_extract_when_baggage_with_valid_format_has_commas_in_values(self): - extracted_context = self.composite_env_propagator_object.extract(getter = getter, carrier = os.environ) + extracted_context = self.composite_env_b3_w3c_baggage_propagator_object.extract(getter = getter, carrier = os.environ) self.assertEqual(baggage.get_all(extracted_context) , {'example1':'value1,value2', 'example2':'value3,value4'}) self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) diff --git a/propagator/opentelemetry-propagator-env/tests/test_b3_single_format_tracecontext_composite_env_propagator.py b/propagator/opentelemetry-propagator-env/tests/test_b3_single_format_tracecontext_composite_env_propagator.py index 12a0ac221db..b40362ad0fb 100644 --- a/propagator/opentelemetry-propagator-env/tests/test_b3_single_format_tracecontext_composite_env_propagator.py +++ b/propagator/opentelemetry-propagator-env/tests/test_b3_single_format_tracecontext_composite_env_propagator.py @@ -30,9 +30,10 @@ class TestB3TracecontextCompositeEnvPropagator(unittest.TestCase): def setUp(self): self.mock_carrier = {} self.composite_env_propagator_b3_w3c_obj = CompositeEnvPropagator([B3SingleFormat(), tracecontext.TraceContextTextMapPropagator()]) + self.composite_env_propagator_w3c_b3_obj = CompositeEnvPropagator([tracecontext.TraceContextTextMapPropagator(), B3SingleFormat()]) self.composite_env_propagator_None_obj = CompositeEnvPropagator(None) - self.composite_env_propagator_obj = CompositeEnvPropagator([B3SingleFormat(), tracecontext.TraceContextTextMapPropagator(), W3CBaggagePropagator()]) - + self.composite_env_propagator_b3_w3c_baggage_obj = CompositeEnvPropagator([B3SingleFormat(), tracecontext.TraceContextTextMapPropagator(), W3CBaggagePropagator()]) + self.composite_env_propagator_w3c_b3_baggage_obj = CompositeEnvPropagator([tracecontext.TraceContextTextMapPropagator(), B3SingleFormat(), W3CBaggagePropagator()]) # Test case for inject def test_inject_when_None_object_passed_to_propagator_and_valid_context_attached(self): dummy_context = create_valid_context_with_baggage() @@ -193,7 +194,7 @@ def test_inject_when_valid_context_with_baggage_attached_for_all_3_formats(self) dummy_context = create_valid_context_with_baggage() token = opentelemetry.context.attach(dummy_context) traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.composite_env_propagator_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + self.composite_env_propagator_b3_w3c_baggage_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) opentelemetry.context.detach(token) self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") @@ -203,7 +204,7 @@ def test_inject_when_valid_context_without_baggage_attached_for_all_3_formats(se dummy_context = create_dummy_context_with_parent_span() token = opentelemetry.context.attach(dummy_context) traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.composite_env_propagator_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + self.composite_env_propagator_b3_w3c_baggage_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) opentelemetry.context.detach(token) self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) self.assertIsNone(self.mock_carrier.get("baggage")) @@ -212,7 +213,7 @@ def test_inject_when_valid_context_without_baggage_attached_for_all_3_formats(se def test_inject_when_invalid_context_with_baggage_attached_or_all_3_formats(self): current_context = create_invalid_context_with_baggage() token = opentelemetry.context.attach(current_context) - self.composite_env_propagator_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) + self.composite_env_propagator_b3_w3c_baggage_obj.inject(carrier = self.mock_carrier, setter = DefaultSetter()) opentelemetry.context.detach(token) self.assertIsNone(self.mock_carrier.get("traceparent")) self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") @@ -221,7 +222,7 @@ def test_inject_when_invalid_context_with_baggage_attached_or_all_3_formats(self def test_inject_when_valid_context_with_baggage_passed_as_params_for_all_3_formats(self): dummy_context = create_valid_context_with_baggage() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.composite_env_propagator_obj.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.composite_env_propagator_b3_w3c_baggage_obj.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) self.assertEqual(self.mock_carrier.get("baggage") , "key1=1,key2=2") self.assertEqual( self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) @@ -229,7 +230,7 @@ def test_inject_when_valid_context_with_baggage_passed_as_params_for_all_3_forma def test_inject_when_valid_context_without_baggage_passed_as_param_for_all_3_formats(self): dummy_context = create_dummy_context_with_parent_span() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.composite_env_propagator_obj.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.composite_env_propagator_b3_w3c_baggage_obj.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) self.assertIsNone(self.mock_carrier.get("baggage")) self.assertEqual(self.mock_carrier.get("b3"), str(traceid)+'-'+str(spanid)+'-'+str(sampled)+'-'+str(parentspanid)) @@ -237,7 +238,7 @@ def test_inject_when_valid_context_without_baggage_passed_as_param_for_all_3_for def test_inject_when_invalid_context_with_baggage_passed_as_params_for_all_3_formats(self): dummy_context = create_invalid_context_with_baggage() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.composite_env_propagator_obj.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.composite_env_propagator_b3_w3c_baggage_obj.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) self.assertIsNone(self.mock_carrier.get("traceparent")) self.assertEqual(self.mock_carrier.get("baggage"), "test1=1,test2=2") self.assertIsNone(self.mock_carrier.get("b3")) @@ -245,7 +246,7 @@ def test_inject_when_invalid_context_with_baggage_passed_as_params_for_all_3_for def test_inject_when_traceid_has_16_hex_char(self): dummy_context = create_dummy_context3() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.composite_env_propagator_obj.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) + self.composite_env_propagator_b3_w3c_baggage_obj.inject(carrier = self.mock_carrier, context = dummy_context, setter = DefaultSetter()) self.assertEqual(self.mock_carrier.get("b3"), str(traceid)+'-'+str(spanid)+'-'+str(sampled)) self.assertEqual(self.mock_carrier.get("traceparent"), '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) self.assertIsNone(self.mock_carrier.get("baggage")) @@ -352,7 +353,7 @@ def test_inject_to_carrier_when_valid_context_with_baggage_attached_for_all_3_fo dummy_context = create_valid_context_with_baggage() token = opentelemetry.context.attach(dummy_context) traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.mock_carrier = self.composite_env_propagator_obj.inject_to_carrier() + self.mock_carrier = self.composite_env_propagator_b3_w3c_baggage_obj.inject_to_carrier() opentelemetry.context.detach(token) self.assertEqual(self.mock_carrier.get("traceparent"), '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) self.assertEqual(self.mock_carrier.get("baggage"), "key1=1,key2=2") @@ -362,7 +363,7 @@ def test_inject_to_carrier_when_valid_context_without_baggage_attached_for_all_3 dummy_context = create_dummy_context_with_parent_span() token = opentelemetry.context.attach(dummy_context) traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.mock_carrier = self.composite_env_propagator_obj.inject_to_carrier() + self.mock_carrier = self.composite_env_propagator_b3_w3c_baggage_obj.inject_to_carrier() opentelemetry.context.detach(token) self.assertEqual(self.mock_carrier.get("traceparent"), '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) self.assertIsNone(self.mock_carrier.get("baggage")) @@ -371,7 +372,7 @@ def test_inject_to_carrier_when_valid_context_without_baggage_attached_for_all_3 def test_inject_to_carrier_when_invalid_context_with_baggage_attached_for_all_3_formats(self): current_context = create_invalid_context_with_baggage() token = opentelemetry.context.attach(current_context) - self.mock_carrier = self.composite_env_propagator_obj.inject_to_carrier() + self.mock_carrier = self.composite_env_propagator_b3_w3c_baggage_obj.inject_to_carrier() opentelemetry.context.detach(token) self.assertIsNone(self.mock_carrier.get("traceparent")) self.assertEqual(self.mock_carrier.get("baggage"), "test1=1,test2=2") @@ -380,7 +381,7 @@ def test_inject_to_carrier_when_invalid_context_with_baggage_attached_for_all_3_ def test_inject_to_carrier_when_valid_context_with_baggage_passed_for_all_3_formats(self): dummy_context = create_valid_context_with_baggage() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.mock_carrier = self.composite_env_propagator_obj.inject_to_carrier(context = dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_baggage_obj.inject_to_carrier(context = dummy_context) self.assertEqual(self.mock_carrier.get("traceparent"),'00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) self.assertEqual(self.mock_carrier.get("baggage"), "key1=1,key2=2") self.assertEqual(self.mock_carrier.get("b3"), str(traceid)+'-'+str(spanid)+'-'+str(sampled)) @@ -388,7 +389,7 @@ def test_inject_to_carrier_when_valid_context_with_baggage_passed_for_all_3_form def test_inject_to_carrier_when_valid_context_without_baggage_passed_for_all_3_formats(self): dummy_context = create_dummy_context_with_parent_span() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.mock_carrier = self.composite_env_propagator_obj.inject_to_carrier(context = dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_baggage_obj.inject_to_carrier(context = dummy_context) self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) self.assertIsNone(self.mock_carrier.get("baggage")) self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)+'-'+str(parentspanid)) @@ -396,7 +397,7 @@ def test_inject_to_carrier_when_valid_context_without_baggage_passed_for_all_3_f def test_inject_to_carrier_when_invalid_context_with_baggage_passed_for_all_3_formats(self): dummy_context = create_invalid_context_with_baggage() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.mock_carrier = self.composite_env_propagator_obj.inject_to_carrier(context = dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_baggage_obj.inject_to_carrier(context = dummy_context) self.assertIsNone(self.mock_carrier.get("traceparent")) self.assertEqual(self.mock_carrier.get("baggage") , "test1=1,test2=2") self.assertIsNone(self.mock_carrier.get("b3")) @@ -404,7 +405,7 @@ def test_inject_to_carrier_when_invalid_context_with_baggage_passed_for_all_3_fo def test_inject_to_carrier_when_traceid_has_16_hex_char(self): dummy_context = create_dummy_context3() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(dummy_context) - self.mock_carrier = self.composite_env_propagator_obj.inject_to_carrier(context = dummy_context) + self.mock_carrier = self.composite_env_propagator_b3_w3c_baggage_obj.inject_to_carrier(context = dummy_context) self.assertEqual(self.mock_carrier.get("b3") , str(traceid)+'-'+str(spanid)+'-'+str(sampled)) self.assertEqual(self.mock_carrier.get("traceparent") , '00'+'-'+str(traceid)+'-'+str(spanid)+'-'+'0'+str(sampled)) self.assertIsNone(self.mock_carrier.get("baggage")) @@ -412,14 +413,14 @@ def test_inject_to_carrier_when_traceid_has_16_hex_char(self): # Test cases for extract_context def test_extract_context_when_no_trace_details_in_environment_variable(self): - extracted_context = self.composite_env_propagator_obj.extract_context() - self.assertEqual(extracted_context , {}) + extracted_context = self.composite_env_propagator_b3_w3c_baggage_obj.extract_context() + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01'}) @mock.patch.dict(os.environ, {'baggage':'key1=value1,=value2'}) def test_extract_context_when_all_3_formats_are_valid(self): - extracted_context = self.composite_env_propagator_obj.extract_context() + extracted_context = self.composite_env_propagator_b3_w3c_baggage_obj.extract_context() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') self.assertEqual(spanid , '136eec09c948be26') @@ -433,7 +434,7 @@ def test_extract_context_when_all_3_formats_are_valid(self): @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01'}) @mock.patch.dict(os.environ, {'baggage':'/value'}) def test_extract_context_when_w3c_and_b3_formats_are_valid_and_baggage_invalid(self): - extracted_context = self.composite_env_propagator_obj.extract_context() + extracted_context = self.composite_env_propagator_b3_w3c_baggage_obj.extract_context() traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') self.assertEqual(spanid , '136eec09c948be26') @@ -445,7 +446,7 @@ def test_extract_context_when_w3c_and_b3_formats_are_valid_and_baggage_invalid(s @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c-01'}) @mock.patch.dict(os.environ, {'baggage':'key1=value1,key2=value2'}) def test_extract_context_when_baggage_is_valid_but_w3c_and_b3_spanid_are_invalid(self): - extracted_context = self.composite_env_propagator_obj.extract_context() + extracted_context = self.composite_env_propagator_b3_w3c_baggage_obj.extract_context() self.assertEqual(baggage.get_all(extracted_context) , {'key1':'value1','key2':'value2'}) self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @@ -454,28 +455,47 @@ def test_extract_context_when_baggage_is_valid_but_w3c_and_b3_spanid_are_invalid @mock.patch.dict(os.environ, {'traceparent':'00-98fea4de58eca772-136eec09c948be26-01'}) @mock.patch.dict(os.environ, {'baggage':'key1=value1,key2=value2'}) def test_extract_context_when_baggage_is_valid_and_traceid_of_b3_and_w3c_have_16_hex_char(self): - extracted_context = self.composite_env_propagator_obj.extract_context() - traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) - self.assertEqual(traceid , '000000000000000098fea4de58eca772') - self.assertEqual(spanid , '136eec09c948be26') - self.assertEqual(sampled , 1) + # order of propagators in composite_propagator: B3, TraceContextTextMapPropagator + extracted_context = self.composite_env_propagator_b3_w3c_baggage_obj.extract_context() + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) val1 = baggage.get_baggage("key1", extracted_context) val2 = baggage.get_baggage("key2", extracted_context) self.assertEqual(val1 , "value1") self.assertEqual(val2 , "value2") + @mock.patch.dict(os.environ, {'b3':'98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-98fea4de58eca772-136eec09c948be26-01'}) + @mock.patch.dict(os.environ, {'baggage':'key1=value1,key2=value2'}) + def test_extract_context_when_baggage_is_valid_and_traceid_of_w3c_and_b3_have_16_hex_char(self): + # order of propagators in composite_propagator: TraceContextTextMapPropagator, B3 + extracted_context = self.composite_env_propagator_w3c_b3_baggage_obj.extract_context() + traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) + self.assertEqual(traceid , '000000000000000098fea4de58eca772') + self.assertEqual(spanid , '136eec09c948be26') + self.assertEqual(sampled , 1) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertEqual(val1 , "value1") + self.assertEqual(val2 , "value2") + @mock.patch.dict(os.environ, {'b3':'8128c50-136eec09c948be26-1-e28bf981e15deb7f'}) @mock.patch.dict(os.environ, {'traceparent':'00-8128c50-136eec09c948be26-01'}) def test_extract_context_when_w3c_and_b3_traceid_is_invalid(self): + extracted_context = self.composite_env_propagator_w3c_b3_obj.extract_context() + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + @mock.patch.dict(os.environ, {'b3':'8128c50-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50-136eec09c948be26-01'}) + def test_extract_context_when_b3_and_w3c_traceid_is_invalid(self): extracted_context = self.composite_env_propagator_b3_w3c_obj.extract_context() - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {'b3':'8128c50f-1-e28bf981e15deb7f'}) @mock.patch.dict(os.environ, {'traceparent':'00-8128c50f-136eec09c-01'}) def test_extract_context_when_w3c_and_b3_traceid_and_spanid_are_invalid(self): extracted_context = self.composite_env_propagator_b3_w3c_obj.extract_context() - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01'}) @@ -494,14 +514,14 @@ def test_extract_context_when_baggage_formatter_is_not_passed_to_propagator(self # Test cases for extract def test_extract_when_no_trace_details(self): - extracted_context = self.composite_env_propagator_obj.extract(getter = getter, carrier = os.environ) - self.assertEqual(extracted_context , {}) + extracted_context = self.composite_env_propagator_b3_w3c_baggage_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01'}) @mock.patch.dict(os.environ, {'baggage':'key1=value1,=value2'}) def test_extract_when_all_3_formats_are_valid(self): - extracted_context = self.composite_env_propagator_obj.extract(getter = getter, carrier = os.environ) + extracted_context = self.composite_env_propagator_b3_w3c_baggage_obj.extract(getter = getter, carrier = os.environ) traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) self.assertEqual(traceid , '8128c50fd8653b5d98fea4de58eca772') self.assertEqual(spanid , '136eec09c948be26') @@ -515,7 +535,7 @@ def test_extract_when_all_3_formats_are_valid(self): @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01'}) @mock.patch.dict(os.environ, {'baggage':'/value1'}) def test_extract_when_w3c_and_b3_formats_are_valid_and_baggage_invalid(self): - extracted_context = self.composite_env_propagator_obj.extract(getter = getter, carrier = os.environ) + extracted_context = self.composite_env_propagator_b3_w3c_baggage_obj.extract(getter = getter, carrier = os.environ) traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) self.assertEqual(traceid,'8128c50fd8653b5d98fea4de58eca772') self.assertEqual(spanid,'136eec09c948be26') @@ -527,7 +547,7 @@ def test_extract_when_w3c_and_b3_formats_are_valid_and_baggage_invalid(self): @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c-01'}) @mock.patch.dict(os.environ, {'baggage':'key1=value1,key2=value2'}) def test_extract_when_baggage_is_valid_but_w3c_and_b3_spanid_are_invalid(self): - extracted_context = self.composite_env_propagator_obj.extract(getter = getter, carrier = os.environ) + extracted_context = self.composite_env_propagator_b3_w3c_baggage_obj.extract(getter = getter, carrier = os.environ) self.assertEqual(baggage.get_all(extracted_context), {'key1':'value1', 'key2':'value2'}) val1 = baggage.get_baggage("key1", extracted_context) val2 = baggage.get_baggage("key2", extracted_context) @@ -538,7 +558,20 @@ def test_extract_when_baggage_is_valid_but_w3c_and_b3_spanid_are_invalid(self): @mock.patch.dict(os.environ, {'traceparent':'00-98fea4de58eca772-136eec09c948be26-01'}) @mock.patch.dict(os.environ, {'baggage':'key1=value1,key2=value2'}) def test_extract_when_baggage_is_valid_and_traceid_of_b3_and_w3c_have_16_hex_char(self): - extracted_context = self.composite_env_propagator_obj.extract(getter = getter, carrier = os.environ) + # order of propagators in composite_propagator: B3, TraceContextTextMapPropagator + extracted_context = self.composite_env_propagator_b3_w3c_baggage_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + val1 = baggage.get_baggage("key1", extracted_context) + val2 = baggage.get_baggage("key2", extracted_context) + self.assertEqual(val1, "value1") + self.assertEqual(val2, "value2") + + @mock.patch.dict(os.environ, {'b3':'98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-98fea4de58eca772-136eec09c948be26-01'}) + @mock.patch.dict(os.environ, {'baggage':'key1=value1,key2=value2'}) + def test_extract_when_baggage_is_valid_and_traceid_of_w3c_and_b3_have_16_hex_char(self): + # order of propagators in composite_propagator: TraceContextTextMapPropagator, B3 + extracted_context = self.composite_env_propagator_w3c_b3_baggage_obj.extract(getter = getter, carrier = os.environ) traceid, spanid, sampled, parentspanid, tracestate = get_details_from_context(extracted_context) self.assertEqual(traceid, '000000000000000098fea4de58eca772') self.assertEqual(spanid, '136eec09c948be26') @@ -549,27 +582,48 @@ def test_extract_when_baggage_is_valid_and_traceid_of_b3_and_w3c_have_16_hex_cha self.assertEqual(val2, "value2") @mock.patch.dict(os.environ, {'baggage':'example1-value1;example2-value2'}) - def test_extract_baggage_invalid_format(self): - extracted_context = self.composite_env_propagator_obj.extract(getter = getter, carrier = os.environ) - self.assertEqual(extracted_context, {}) + def test_extract_when_baggage_format_invalid_and_w3c_b3_baggage_propagators_passed_to_composite_propagator(self): + extracted_context = self.composite_env_propagator_w3c_b3_baggage_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + @mock.patch.dict(os.environ, {'baggage':'example1-value1;example2-value2'}) + def test_extract_when_baggage_format_invalid_and_b3_w3c_baggage_propagators_passed_to_composite_propagator(self): + extracted_context = self.composite_env_propagator_b3_w3c_baggage_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {'baggage':'example1=value1%2Cvalue2,example2=value3%2Cvalue4'}) def test_extract_when_baggage_with_valid_format_has_commas_in_values(self): - extracted_context = self.composite_env_propagator_obj.extract(getter = getter, carrier = os.environ) + extracted_context = self.composite_env_propagator_b3_w3c_baggage_obj.extract(getter = getter, carrier = os.environ) self.assertEqual(baggage.get_all(extracted_context) , {'example1':'value1,value2', 'example2':'value3,value4'}) self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {'b3':'8128c50f-136eec09c948be26-1-e28bf981e15deb7f'}) @mock.patch.dict(os.environ, {'traceparent':'00-8128c50f-136eec09c948be26-01'}) def test_extract_when_traceid_is_invalid_for_w3c_and_b3(self): + # order of propagators in composite propagator: TraceContextTextMapPropagator, B3 + extracted_context = self.composite_env_propagator_w3c_b3_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + @mock.patch.dict(os.environ, {'b3':'8128c50f-136eec09c948be26-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50f-136eec09c948be26-01'}) + def test_extract_when_traceid_is_invalid_for_b3_and_w3c(self): + # order of propagators in composite propagator: B3, TraceContextTextMapPropagator extracted_context = self.composite_env_propagator_b3_w3c_obj.extract(getter = getter, carrier = os.environ) - self.assertEqual(extracted_context, {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {'b3':'8128c50f-136eec09c-1-e28bf981e15deb7f'}) @mock.patch.dict(os.environ, {'traceparent':'00-8128c50f-136eec09c-01'}) def test_extract_when_traceid_and_spanid_are_invalid_for_w3c_and_b3(self): + # order of propagators in composite propagator: TraceContextTextMapPropagator, B3 + extracted_context = self.composite_env_propagator_w3c_b3_obj.extract(getter = getter, carrier = os.environ) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) + + @mock.patch.dict(os.environ, {'b3':'8128c50f-136eec09c-1-e28bf981e15deb7f'}) + @mock.patch.dict(os.environ, {'traceparent':'00-8128c50f-136eec09c-01'}) + def test_extract_when_traceid_and_spanid_are_invalid_for_b3_and_w3c(self): + # order of propagators in composite propagator: B3, TraceContextTextMapPropagator extracted_context = self.composite_env_propagator_b3_w3c_obj.extract(getter = getter, carrier = os.environ) - self.assertEqual(extracted_context, {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {'b3':'8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f'}) @mock.patch.dict(os.environ, {'traceparent':'00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01'}) diff --git a/propagator/opentelemetry-propagator-env/tests/test_tracecontext_baggage_composite_env_propagator.py b/propagator/opentelemetry-propagator-env/tests/test_tracecontext_baggage_composite_env_propagator.py index 944c89cc02c..a516eb9bb0f 100644 --- a/propagator/opentelemetry-propagator-env/tests/test_tracecontext_baggage_composite_env_propagator.py +++ b/propagator/opentelemetry-propagator-env/tests/test_tracecontext_baggage_composite_env_propagator.py @@ -307,7 +307,7 @@ def test_inject_when_traceid_has_16_hex_char(self): def test_extract_when_no_trace_details(self): extracted_context = self.composite_env_propagator_baggage_w3c_object.extract(getter = getter, carrier = os.environ) - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {"b3": "8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f"}) @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) @@ -356,13 +356,13 @@ def test_extract_when_baggage_is_valid_and_traceid_of_w3c_has_16_hex_char(self): @mock.patch.dict(os.environ, {"traceparent": "00-8128c5-136eec09c948be26-01"}) def test_extract_when_w3c_traceid_is_invalid(self): extracted_context = self.composite_env_propagator_baggage_w3c_object.extract(getter = getter, carrier = os.environ) - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {"b3": "8128c50fd8653b5d98fea4de-136eec09c-1-e28bf981e15deb7f"}) - @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de-136eec09c-01"}) + @mock.patch.dict(os.environ, {"traceparent": "00-8128c50-136eec09c-01"}) def test_extract_when_w3c_traceid_and_spanid_are_invalid(self): extracted_context = self.composite_env_propagator_baggage_w3c_object.extract(getter = getter, carrier = os.environ) - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {"b3": "8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f"}) @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) @@ -380,7 +380,7 @@ def test_extract_when_baggage_is_not_present_in_os_environ(self): @mock.patch.dict(os.environ, {"baggage": "example1-value1;example2-value2"}) def test_extract_baggage_invalid_format(self): extracted_context = self.composite_env_propagator_baggage_w3c_object.extract(getter = getter, carrier = os.environ) - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {"baggage": "example1=value1%2Cvalue2,example2=value3%2Cvalue4"}) def test_extract_when_baggage_with_valid_format_has_commas_in_values(self): @@ -393,7 +393,7 @@ def test_extract_when_baggage_with_valid_format_has_commas_in_values(self): def test_extract_context_when_no_trace_details(self): extracted_context = self.composite_env_propagator_baggage_w3c_object.extract_context() - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {"b3": "8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f"}) @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) @@ -444,13 +444,13 @@ def test_extract_context_when_baggage_is_valid_and_traceid_of_w3c_has_16_hex_cha @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de-136eec09c948be26-01"}) def test_extract_context_when_w3c_traceid_is_invalid(self): extracted_context = self.composite_env_propagator_baggage_w3c_object.extract_context() - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {"b3": "8128c50fd8653b5d98fea4de-136eec09c-1-e28bf981e15deb7f"}) @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de-136eec09c-01"}) def test_extract_context_when_w3c_traceid_and_spanid_are_invalid(self): extracted_context = self.composite_env_propagator_baggage_w3c_object.extract_context() - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {"b3": "8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-1-e28bf981e15deb7f"}) @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) @@ -468,7 +468,7 @@ def test_extract_context_when_baggage_is_not_present_os_environ(self): @mock.patch.dict(os.environ, {"baggage": "example1-value1;example2-value2"}) def test_extract_context_baggage_invalid_format(self): extracted_context = self.composite_env_propagator_baggage_w3c_object.extract_context() - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {"baggage": "example1=value1%2Cvalue2,example2=value3%2Cvalue4"}) def test_extract_context_when_baggage_with_valid_format_has_commas_in_values(self): diff --git a/propagator/opentelemetry-propagator-env/tests/test_tracecontext_composite_env_propagator.py b/propagator/opentelemetry-propagator-env/tests/test_tracecontext_composite_env_propagator.py index d2302bb1fd8..c264f43bee2 100644 --- a/propagator/opentelemetry-propagator-env/tests/test_tracecontext_composite_env_propagator.py +++ b/propagator/opentelemetry-propagator-env/tests/test_tracecontext_composite_env_propagator.py @@ -142,27 +142,27 @@ def test_extract_valid_w3cformat_present_in_environment_variable(self): @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec06-a"}) def test_extract_w3cformat_with_invalid_span_id(self): extracted_context = self.composite_env_propagator_w3c_obj.extract(getter = getter, carrier = os.environ) - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {"traceparent": "00-8128c50ed865ca77-136eec06ae45ae57-1"}) def test_extract_w3cformat_with_invalid_trace_id_having_16_hex_char(self): extracted_context = self.composite_env_propagator_w3c_obj.extract(getter = getter, carrier = os.environ) - self.assertEqual( extracted_context , {}) + self.assertEqual( opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd865ca77-136eec06-1"}) def test_extract_w3cformat_with_invalid_trace_id_and_span_id(self): extracted_context = self.composite_env_propagator_w3c_obj.extract(getter = getter, carrier = os.environ) - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) def test_extract_when_no_trace_details_in_w3c_format(self): extracted_context = self.composite_env_propagator_w3c_obj.extract(getter = getter, carrier = os.environ) - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) # test cases for extract_context def test_extract_context_when_no_trace_details(self): extracted_context = self.composite_env_propagator_w3c_obj.extract_context() - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01"}) def test_extract_context_valid_w3cformat_in_environment_variable(self): @@ -176,14 +176,14 @@ def test_extract_context_valid_w3cformat_in_environment_variable(self): @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec06-a"}) def test_extract_context_w3cformat_with_invalid_span_id(self): extracted_context = self.composite_env_propagator_w3c_obj.extract_context() - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {"traceparent": "00-8128c50ed865ca77-136eec06ae45ae57-1"}) def test_extract_context_w3cformat_with_invalid_trace_id_having_16_hex_char(self): extracted_context = self.composite_env_propagator_w3c_obj.extract_context() - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd865ca77-136eec06-1"}) def test_extract_context_w3cformat_with_invalid_trace_id_and_span_id(self): extracted_context = self.composite_env_propagator_w3c_obj.extract_context() - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) diff --git a/propagator/opentelemetry-propagator-env/tests/test_tracecontext_env_propagator.py b/propagator/opentelemetry-propagator-env/tests/test_tracecontext_env_propagator.py index 2e9503bc50c..293989e3414 100644 --- a/propagator/opentelemetry-propagator-env/tests/test_tracecontext_env_propagator.py +++ b/propagator/opentelemetry-propagator-env/tests/test_tracecontext_env_propagator.py @@ -109,22 +109,22 @@ def test_inject_to_carrier_when_attached_context_and_context_passed_as_param_are def test_extract_context_when_no_trace_details_in_w3c_format(self): extracted_context_w3c = self.env_propagator_w3c_obj.extract_context() - self.assertEqual(extracted_context_w3c , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context_w3c), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {'traceparent': '00-123-136eec09c948be26-1'}) def test_extract_context_when_traceid_format_does_not_match_regex_for_w3c(self): extracted_context = self.env_propagator_w3c_obj.extract_context() - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {'traceparent': '00-8128c50fd8653b5d98fea4de58eca772-136e-1'}) def test_extract_context_when_spanid_format_does_not_match_regex_for_w3c(self): extracted_context = self.env_propagator_w3c_obj.extract_context() - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {'traceparent': '00-123-136-1'}) def test_extract_context_when_traceid_and_spanid_format_do_not_match_regex_for_w3c(self): extracted_context = self.env_propagator_w3c_obj.extract_context() - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {'traceparent': '00-8128c50fd8653b5d98fea4de58eca772-136eec09c948be26-01'}) @mock.patch.dict(os.environ, {'tracestate': 'congo=t61rcWkgMzE'}) @@ -189,23 +189,23 @@ def test_extract_when_valid_w3cformat_in_environment_variable(self): @mock.patch.dict(os.environ, {"traceparent": "00-8128ca772-136eec06-01"}) def test_extract_when_invalid_w3cformat_in_environment_variable(self): extracted_context = self.env_propagator_w3c_obj.extract(getter = getter, carrier = os.environ) - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d98fea4de58eca772-136eec06-01"}) def test_extract_w3cformat_with_invalid_span_id(self): extracted_context = self.env_propagator_w3c_obj.extract(getter = getter, carrier = os.environ) - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd8653b5d-136eec06ae45ae57-01"}) def test_extract_w3cformat_with_trace_id_having_16_hex_char(self): extracted_context = self.env_propagator_w3c_obj.extract(getter = getter, carrier = os.environ) - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) @mock.patch.dict(os.environ, {"traceparent": "00-8128c50fd865ca77-136eec06-01"}) def test_extract_w3cformat_with_invalid_trace_id_and_span_id(self): extracted_context = self.env_propagator_w3c_obj.extract(getter = getter, carrier = os.environ) - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) def test_extract_when_no_trace_details_in_w3c_format(self): extracted_context = self.env_propagator_w3c_obj.extract(getter = getter, carrier = os.environ) - self.assertEqual(extracted_context , {}) + self.assertEqual(opentelemetry.trace.get_current_span(extracted_context), opentelemetry.trace.span.INVALID_SPAN) From b544aadc14c2d376767db3c358d8e0f6e6307ff7 Mon Sep 17 00:00:00 2001 From: Divya Sharma Date: Mon, 13 Sep 2021 16:01:54 -0700 Subject: [PATCH 4/6] chore(setup): add b3 propagator as dependency for tests --- propagator/opentelemetry-propagator-env/setup.cfg | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/propagator/opentelemetry-propagator-env/setup.cfg b/propagator/opentelemetry-propagator-env/setup.cfg index 813bd61927e..d03c01b58c1 100644 --- a/propagator/opentelemetry-propagator-env/setup.cfg +++ b/propagator/opentelemetry-propagator-env/setup.cfg @@ -43,7 +43,7 @@ install_requires = opentelemetry-api ~= 1.3 [options.extras_require] -test = +test = opentelemetry-propagator-b3 [options.packages.find] where = src From fc1d6f4ee80acaec6df3fcf683e687f1e8884bf2 Mon Sep 17 00:00:00 2001 From: Divya Sharma Date: Mon, 13 Sep 2021 16:06:17 -0700 Subject: [PATCH 5/6] chore(setup): add version for b3 propagator in setup.cfg --- propagator/opentelemetry-propagator-env/setup.cfg | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/propagator/opentelemetry-propagator-env/setup.cfg b/propagator/opentelemetry-propagator-env/setup.cfg index d03c01b58c1..86c04c9b6a5 100644 --- a/propagator/opentelemetry-propagator-env/setup.cfg +++ b/propagator/opentelemetry-propagator-env/setup.cfg @@ -43,7 +43,7 @@ install_requires = opentelemetry-api ~= 1.3 [options.extras_require] -test = opentelemetry-propagator-b3 +test = opentelemetry-propagator-b3 ~= 1.3 [options.packages.find] where = src From 1206d88778fc7fb002d5c1dd1d75e1828a7be4c8 Mon Sep 17 00:00:00 2001 From: Divya Sharma Date: Mon, 13 Sep 2021 17:00:45 -0700 Subject: [PATCH 6/6] chore(setup): modify extras_requires section in setup.cfg --- propagator/opentelemetry-propagator-env/setup.cfg | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/propagator/opentelemetry-propagator-env/setup.cfg b/propagator/opentelemetry-propagator-env/setup.cfg index 86c04c9b6a5..02f658e7b35 100644 --- a/propagator/opentelemetry-propagator-env/setup.cfg +++ b/propagator/opentelemetry-propagator-env/setup.cfg @@ -43,7 +43,8 @@ install_requires = opentelemetry-api ~= 1.3 [options.extras_require] -test = opentelemetry-propagator-b3 ~= 1.3 +test = + opentelemetry-propagator-b3 ~= 1.3 [options.packages.find] where = src