Allow to override global tracer_provider after tracers creation

CHANGELOG.md

@@ -46,6 +46,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Adding `opentelemetry-distro` package to add default configuration for
   span exporter to OTLP
   ([#1482](https://github.com/open-telemetry/opentelemetry-python/pull/1482))
+- Allow to set global `tracer_provider` after `tracer`s creation
+  ([#1445](https://github.com/open-telemetry/opentelemetry-python/pull/1445))
 
 ### Changed
 - `opentelemetry-exporter-zipkin` Updated zipkin exporter status code and error tag

opentelemetry-api/src/opentelemetry/trace/__init__.py

@@ -76,6 +76,7 @@
 
 import abc
 import enum
+import functools
 import typing
 from contextlib import contextmanager
 from logging import getLogger
@@ -410,23 +411,99 @@ def use_span(
         yield
 
 
+class _ProxyTracer(Tracer):
+    """Proxies all calls to current TracerProvider
+    """
+
+    def __init__(
+        self, get_current_tracer: typing.Callable[[], "Tracer"],
+    ) -> None:
+        self._get_current_tracer = get_current_tracer
+
+    def start_span(
+        self,
+        name: str,
+        context: typing.Optional[Context] = None,
+        kind: SpanKind = SpanKind.INTERNAL,
+        attributes: types.Attributes = None,
+        links: typing.Sequence[Link] = (),
+        start_time: typing.Optional[int] = None,
+        record_exception: bool = True,
+        set_status_on_exception: bool = True,
+    ) -> "Span":
+        return self._get_current_tracer().start_span(
+            name=name,
+            context=context,
+            kind=kind,
+            attributes=attributes,
+            links=links,
+            start_time=start_time,
+            record_exception=record_exception,
+            set_status_on_exception=set_status_on_exception,
+        )
+
+    @contextmanager  # type: ignore
+    def start_as_current_span(
+        self,
+        name: str,
+        context: typing.Optional[Context] = None,
+        kind: SpanKind = SpanKind.INTERNAL,
+        attributes: types.Attributes = None,
+        links: typing.Sequence[Link] = (),
+        start_time: typing.Optional[int] = None,
+        record_exception: bool = True,
+        set_status_on_exception: bool = True,
+    ) -> typing.Iterator["Span"]:
+        with self._get_current_tracer().start_as_current_span(
+            name=name,
+            context=context,
+            kind=kind,
+            attributes=attributes,
+            links=links,
+            start_time=start_time,
+            record_exception=record_exception,
+            set_status_on_exception=set_status_on_exception,
+        ) as span:
+            yield span
+
+    @contextmanager  # type: ignore
+    def use_span(
+        self, span: "Span", end_on_exit: bool = False,
+    ) -> typing.Iterator[None]:
+        with self._get_current_tracer().use_span(
+            span=span, end_on_exit=end_on_exit,
+        ) as context:
+            yield context
+
+
 _TRACER_PROVIDER = None
 
 
+@functools.lru_cache(maxsize=None)  # type: ignore
+def _get_current_tracer(*args: typing.Any, **kwargs: typing.Any) -> "Tracer":
+    tracer_provider = get_tracer_provider()
+    return tracer_provider.get_tracer(*args, **kwargs)  # type: ignore
+
+
 def get_tracer(
     instrumenting_module_name: str,
     instrumenting_library_version: str = "",
     tracer_provider: typing.Optional[TracerProvider] = None,
 ) -> "Tracer":
     """Returns a `Tracer` for use by the given instrumentation library.
 
-    This function is a convenience wrapper for
-    opentelemetry.trace.TracerProvider.get_tracer.
-
-    If tracer_provider is ommited the current configured one is used.
+    If tracer_provider is omitted it returns a _ProxyTracer
+    which redirects calls to a current instrumentation library.
     """
     if tracer_provider is None:
-        tracer_provider = get_tracer_provider()
+        return _ProxyTracer(
+            functools.partial(
+                _get_current_tracer,
+                instrumenting_module_name=instrumenting_module_name,
+                instrumenting_library_version=instrumenting_library_version,
+            )
+        )
+
     return tracer_provider.get_tracer(
         instrumenting_module_name, instrumenting_library_version
     )
@@ -445,14 +522,14 @@ def set_tracer_provider(tracer_provider: TracerProvider) -> None:
         return
 
     _TRACER_PROVIDER = tracer_provider
+    _get_current_tracer.cache_clear()  # pylint: disable=no-member
 
 
 def get_tracer_provider() -> TracerProvider:
     """Gets the current global :class:`~.TracerProvider` object."""
-    global _TRACER_PROVIDER  # pylint: disable=global-statement
 
     if _TRACER_PROVIDER is None:
-        _TRACER_PROVIDER = _load_trace_provider("tracer_provider")
+        return _load_trace_provider("tracer_provider")
 
     return _TRACER_PROVIDER
 

opentelemetry-api/tests/trace/test_globals.py

@@ -1,25 +1,93 @@
 import unittest
-from unittest.mock import patch
+from unittest.mock import MagicMock, patch
 
 from opentelemetry import context, trace
 
 
 class TestGlobals(unittest.TestCase):
-    def setUp(self):
-        self._patcher = patch("opentelemetry.trace._TRACER_PROVIDER")
-        self._mock_tracer_provider = self._patcher.start()
-
     def tearDown(self) -> None:
-        self._patcher.stop()
+        trace._TRACER_PROVIDER = None  # pylint: disable=protected-access
 
     def test_get_tracer(self):
-        """trace.get_tracer should proxy to the global tracer provider."""
-        trace.get_tracer("foo", "var")
-        self._mock_tracer_provider.get_tracer.assert_called_with("foo", "var")
+        """trace.get_tracer should create a proxy to the global tracer provider."""
+        tracer_provider = (
+            trace._TRACER_PROVIDER
+        ) = MagicMock()  # pylint: disable=protected-access
+
+        tracer = trace.get_tracer("foo", "var")
+
+        tracer_provider.get_tracer.assert_not_called()
+        self.assertIsInstance(
+            tracer, trace._ProxyTracer  # pylint: disable=protected-access
+        )
+
+        tracer.start_span("one")
+        tracer.start_span("two")
+        tracer_provider.get_tracer.assert_called_once_with(
+            instrumenting_module_name="foo",
+            instrumenting_library_version="var",
+        )
+
+        tracer_provider.reset_mock()
         mock_provider = unittest.mock.Mock()
         trace.get_tracer("foo", "var", mock_provider)
+        tracer_provider.get_tracer.assert_not_called()
         mock_provider.get_tracer.assert_called_with("foo", "var")
 
+    def test_set_tracer_provider(self):
+        """trace.get_tracer should update global tracer provider."""
+        self.assertIsNone(
+            trace._TRACER_PROVIDER,  # pylint: disable=protected-access
+        )
+
+        tracer_provider1 = trace.DefaultTracerProvider()
+        trace.set_tracer_provider(tracer_provider1)
+        self.assertIs(
+            trace._TRACER_PROVIDER,  # pylint: disable=protected-access
+            tracer_provider1,
+        )
+
+        tracer_provider2 = trace.DefaultTracerProvider()
+        trace.set_tracer_provider(tracer_provider2)
+        self.assertIs(
+            trace._TRACER_PROVIDER,  # pylint: disable=protected-access
+            tracer_provider1,
+        )
+
+    @patch("opentelemetry.trace._load_trace_provider")
+    def test_get_tracer_provider(self, load_trace_provider_mock: "MagicMock"):  # type: ignore
+        """trace.get_tracer_provider should get or create a global tracer provider."""
+
+        # Get before set
+        load_trace_provider_mock.return_value = trace.DefaultTracerProvider()
+
+        tracer_provider = trace.get_tracer_provider()
+        self.assertIsNone(
+            trace._TRACER_PROVIDER  # pylint: disable=protected-access
+        )
+        self.assertIs(
+            tracer_provider, load_trace_provider_mock.return_value,
+        )
+        load_trace_provider_mock.assert_called_once_with("tracer_provider")
+        load_trace_provider_mock.reset_mock()
+
+        # Set
+        tracer_provider1 = trace.DefaultTracerProvider()
+        trace.set_tracer_provider(tracer_provider1)
+        self.assertIs(
+            trace._TRACER_PROVIDER,  # pylint: disable=protected-access
+            tracer_provider1,
+        )
+
+        # And get
+        tracer_provider2 = trace.get_tracer_provider()
+        self.assertIs(
+            trace._TRACER_PROVIDER,  # pylint: disable=protected-access
+            tracer_provider2,
+        )
+        self.assertIs(tracer_provider1, tracer_provider2)
+        load_trace_provider_mock.assert_not_called()
+
 
 class TestTracer(unittest.TestCase):
     def setUp(self):
@@ -38,3 +106,106 @@ def test_get_current_span(self):
         finally:
             context.detach(token)
         self.assertEqual(trace.get_current_span(), trace.INVALID_SPAN)
+
+
+class TestProxyTracer(unittest.TestCase):
+    def setUp(self):
+        self.proxy_tracer = trace.get_tracer("foo", "var")
+        self.inner_tracer = MagicMock(wraps=trace.DefaultTracer())
+
+        tracer_provider = MagicMock(wraps=trace.DefaultTracerProvider())
+        tracer_provider.get_tracer.return_value = self.inner_tracer
+        trace.set_tracer_provider(tracer_provider)
+
+    def tearDown(self) -> None:
+        trace._TRACER_PROVIDER = None  # pylint: disable=protected-access
+
+    def test_start_span(self):
+        """ProxyTracer should call `start_span` on a real `Tracer`
+        """
+        self.inner_tracer.start_span.assert_not_called()
+
+        span = self.proxy_tracer.start_span("span1")
+        self.assertIs(span, trace.INVALID_SPAN)
+        self.inner_tracer.start_span.assert_called_once_with(
+            name="span1",
+            context=None,
+            kind=trace.SpanKind.INTERNAL,
+            attributes=None,
+            links=(),
+            start_time=None,
+            record_exception=True,
+            set_status_on_exception=True,
+        )
+
+    def test_start_as_current_span(self):
+        """ProxyTracer should call `start_as_current_span` on a real `Tracer`
+        """
+        self.inner_tracer.start_as_current_span.assert_not_called()
+
+        with self.proxy_tracer.start_as_current_span("span1") as span:
+            self.assertIs(span, trace.INVALID_SPAN)
+            self.inner_tracer.start_as_current_span.assert_called_once_with(
+                name="span1",
+                context=None,
+                kind=trace.SpanKind.INTERNAL,
+                attributes=None,
+                links=(),
+                start_time=None,
+                record_exception=True,
+                set_status_on_exception=True,
+            )
+
+        self.inner_tracer.start_as_current_span.reset_mock()
+
+        @self.proxy_tracer.start_as_current_span("span1")
+        def func(arg: str, kwarg: str) -> str:
+            self.assertEqual(arg, "argval")
+            self.assertEqual(kwarg, "kwargval")
+            return "retval"
+
+        self.inner_tracer.start_as_current_span.assert_not_called()
+
+        result = func("argval", kwarg="kwargval")
+        self.assertEqual(result, "retval")
+
+        self.inner_tracer.start_as_current_span.assert_called_once_with(
+            name="span1",
+            context=None,
+            kind=trace.SpanKind.INTERNAL,
+            attributes=None,
+            links=(),
+            start_time=None,
+            record_exception=True,
+            set_status_on_exception=True,
+        )
+
+    def test_use_span(self):
+        """ProxyTracer should call `use_span` on a real `Tracer`
+        """
+        self.inner_tracer.use_span.assert_not_called()
+
+        span = self.proxy_tracer.start_span("span1")
+
+        with self.proxy_tracer.use_span(span) as current_context:
+            self.assertIsNone(current_context)
+            self.inner_tracer.use_span.assert_called_once_with(
+                span=span, end_on_exit=False,
+            )
+
+        self.inner_tracer.use_span.reset_mock()
+
+        @self.proxy_tracer.use_span(span)
+        def func(arg: str, kwarg: str) -> str:
+            self.assertEqual(arg, "argval")
+            self.assertEqual(kwarg, "kwargval")
+            return "retval"
+
+        self.inner_tracer.use_span.assert_not_called()
+
+        result = func("argval", kwarg="kwargval")
+        self.assertEqual(result, "retval")
+
+        self.inner_tracer.use_span.assert_called_once_with(
+            span=span, end_on_exit=False,
+        )

opentelemetry-sdk/tests/trace/test_globals.py

@@ -1,25 +1,17 @@
 # type:ignore
 import unittest
-from logging import WARNING
 
 from opentelemetry import trace
 from opentelemetry.sdk.trace import TracerProvider  # type:ignore
 
 
 class TestGlobals(unittest.TestCase):
-    def test_tracer_provider_override_warning(self):
-        """trace.set_tracer_provider should throw a warning when overridden"""
-        trace.set_tracer_provider(TracerProvider())
-        tracer_provider = trace.get_tracer_provider()
-        with self.assertLogs(level=WARNING) as test:
-            trace.set_tracer_provider(TracerProvider())
-            self.assertEqual(
-                test.output,
-                [
-                    (
-                        "WARNING:opentelemetry.trace:Overriding of current "
-                        "TracerProvider is not allowed"
-                    )
-                ],
-            )
+    def test_tracer_provider_override(self):
+        """trace.set_tracer_provider should override global tracer"""
+        tracer_provider = TracerProvider()
+        trace.set_tracer_provider(tracer_provider)
+        self.assertIs(tracer_provider, trace.get_tracer_provider())
+
+        new_tracer_provider = TracerProvider()
+        trace.set_tracer_provider(new_tracer_provider)
         self.assertIs(tracer_provider, trace.get_tracer_provider())