Update instrumentations to use tracer_provider for creating tracer if given, otherwise use global tracer provider

instrumentation/opentelemetry-instrumentation-asgi/src/opentelemetry/instrumentation/asgi/__init__.py

@@ -166,9 +166,15 @@ class OpenTelemetryMiddleware:
             Optional: Defaults to get_default_span_details.
     """
 
-    def __init__(self, app, excluded_urls=None, span_details_callback=None):
+    def __init__(
+        self,
+        app,
+        excluded_urls=None,
+        span_details_callback=None,
+        tracer_provider=None,
+    ):
         self.app = guarantee_single_callable(app)
-        self.tracer = trace.get_tracer(__name__, __version__)
+        self.tracer = trace.get_tracer(__name__, __version__, tracer_provider)
         self.span_details_callback = (
             span_details_callback or get_default_span_details
         )

instrumentation/opentelemetry-instrumentation-asyncpg/src/opentelemetry/instrumentation/asyncpg/__init__.py

@@ -89,13 +89,11 @@ def __init__(self, capture_parameters=False):
         self.capture_parameters = capture_parameters
 
     def _instrument(self, **kwargs):
-        tracer_provider = kwargs.get(
-            "tracer_provider", trace.get_tracer_provider()
-        )
+        tracer_provider = kwargs.get("tracer_provider")
         setattr(
             asyncpg,
             _APPLIED,
-            tracer_provider.get_tracer("asyncpg", __version__),
+            trace.get_tracer(__name__, __version__, tracer_provider),
         )
 
         for method in [

instrumentation/opentelemetry-instrumentation-django/src/opentelemetry/instrumentation/django/__init__.py

@@ -44,6 +44,8 @@ def _instrument(self, **kwargs):
         if environ.get(OTEL_PYTHON_DJANGO_INSTRUMENT) == "False":
             return
 
+        _DjangoMiddleware._tracer_provider = kwargs.get("tracer_provider")
+
         # This can not be solved, but is an inherent problem of this approach:
         # the order of middleware entries matters, and here you have no control
         # on that:

instrumentation/opentelemetry-instrumentation-django/src/opentelemetry/instrumentation/django/middleware.py

@@ -61,6 +61,7 @@ class _DjangoMiddleware(MiddlewareMixin):
 
     _traced_request_attrs = get_traced_request_attrs("DJANGO")
     _excluded_urls = get_excluded_urls("DJANGO")
+    _tracer_provider = None
 
     @staticmethod
     def _get_span_name(request):
@@ -99,7 +100,11 @@ def process_request(self, request):
 
         token = attach(extract(request_meta, getter=wsgi_getter))
 
-        tracer = get_tracer(__name__, __version__)
+        tracer = get_tracer(
+            __name__,
+            __version__,
+            tracer_provider=_DjangoMiddleware._tracer_provider,
+        )
 
         span = tracer.start_span(
             self._get_span_name(request),

instrumentation/opentelemetry-instrumentation-falcon/src/opentelemetry/instrumentation/falcon/__init__.py

@@ -83,19 +83,26 @@ class FalconInstrumentor(BaseInstrumentor):
 
     def _instrument(self, **kwargs):
         self._original_falcon_api = falcon.API
+        _InstrumentedFalconAPI._tracer_provider = kwargs.get("tracer_provider")
         falcon.API = _InstrumentedFalconAPI
 
     def _uninstrument(self, **kwargs):
         falcon.API = self._original_falcon_api
 
 
 class _InstrumentedFalconAPI(falcon.API):
+    _tracer_provider = None
+
     def __init__(self, *args, **kwargs):
         middlewares = kwargs.pop("middleware", [])
         if not isinstance(middlewares, (list, tuple)):
             middlewares = [middlewares]
 
-        self._tracer = trace.get_tracer(__name__, __version__)
+        self._tracer = trace.get_tracer(
+            __name__,
+            __version__,
+            tracer_provider=_InstrumentedFalconAPI._tracer_provider,
+        )
         trace_middleware = _TraceMiddleware(
             self._tracer, kwargs.get("traced_request_attributes")
         )

instrumentation/opentelemetry-instrumentation-fastapi/src/opentelemetry/instrumentation/fastapi/__init__.py

@@ -31,32 +31,37 @@ class FastAPIInstrumentor(BaseInstrumentor):
     _original_fastapi = None
 
     @staticmethod
-    def instrument_app(app: fastapi.FastAPI):
+    def instrument_app(app: fastapi.FastAPI, tracer_provider=None):
         """Instrument an uninstrumented FastAPI application.
         """
         if not getattr(app, "is_instrumented_by_opentelemetry", False):
             app.add_middleware(
                 OpenTelemetryMiddleware,
                 excluded_urls=_excluded_urls,
                 span_details_callback=_get_route_details,
+                tracer_provider=tracer_provider,
             )
             app.is_instrumented_by_opentelemetry = True
 
     def _instrument(self, **kwargs):
         self._original_fastapi = fastapi.FastAPI
+        _InstrumentedFastAPI._tracer_provider = kwargs.get("tracer_provider")
         fastapi.FastAPI = _InstrumentedFastAPI
 
     def _uninstrument(self, **kwargs):
         fastapi.FastAPI = self._original_fastapi
 
 
 class _InstrumentedFastAPI(fastapi.FastAPI):
+    _tracer_provider = None
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.add_middleware(
             OpenTelemetryMiddleware,
             excluded_urls=_excluded_urls,
             span_details_callback=_get_route_details,
+            tracer_provider=_InstrumentedFastAPI._tracer_provider,
         )
 
 

instrumentation/opentelemetry-instrumentation-flask/src/opentelemetry/instrumentation/flask/__init__.py

@@ -109,7 +109,7 @@ def _start_response(status, response_headers, *args, **kwargs):
     return _wrapped_app
 
 
-def _wrapped_before_request(name_callback):
+def _wrapped_before_request(name_callback, tracer_provider=None):
     def _before_request():
         if _excluded_urls.url_disabled(flask.request.url):
             return
@@ -120,7 +120,7 @@ def _before_request():
             extract(flask_request_environ, getter=otel_wsgi.wsgi_getter)
         )
 
-        tracer = trace.get_tracer(__name__, __version__)
+        tracer = trace.get_tracer(__name__, __version__, tracer_provider)
 
         span = tracer.start_span(
             span_name,
@@ -171,6 +171,7 @@ def _teardown_request(exc):
 class _InstrumentedFlask(flask.Flask):
 
     name_callback = get_default_span_name
+    _tracer_provider = None
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -179,7 +180,8 @@ def __init__(self, *args, **kwargs):
         self.wsgi_app = _rewrapped_app(self.wsgi_app)
 
         _before_request = _wrapped_before_request(
-            _InstrumentedFlask.name_callback
+            _InstrumentedFlask.name_callback,
+            tracer_provider=_InstrumentedFlask._tracer_provider,
         )
         self._before_request = _before_request
         self.before_request(_before_request)
@@ -196,12 +198,14 @@ class FlaskInstrumentor(BaseInstrumentor):
     def _instrument(self, **kwargs):
         self._original_flask = flask.Flask
         name_callback = kwargs.get("name_callback")
+        tracer_provider = kwargs.get("tracer_provider")
         if callable(name_callback):
             _InstrumentedFlask.name_callback = name_callback
+        _InstrumentedFlask._tracer_provider = tracer_provider
         flask.Flask = _InstrumentedFlask
 
     def instrument_app(
-        self, app, name_callback=get_default_span_name
+        self, app, name_callback=get_default_span_name, tracer_provider=None
     ):  # pylint: disable=no-self-use
         if not hasattr(app, "_is_instrumented"):
             app._is_instrumented = False
@@ -210,7 +214,9 @@ def instrument_app(
             app._original_wsgi_app = app.wsgi_app
             app.wsgi_app = _rewrapped_app(app.wsgi_app)
 
-            _before_request = _wrapped_before_request(name_callback)
+            _before_request = _wrapped_before_request(
+                name_callback, tracer_provider=tracer_provider
+            )
             app._before_request = _before_request
             app.before_request(_before_request)
             app.teardown_request(_teardown_request)

instrumentation/opentelemetry-instrumentation-grpc/src/opentelemetry/instrumentation/grpc/__init__.py

@@ -147,13 +147,18 @@ class GrpcInstrumentorServer(BaseInstrumentor):
 
     def _instrument(self, **kwargs):
         self._original_func = grpc.server
+        tracer_provider = kwargs.get("tracer_provider")
 
         def server(*args, **kwargs):
             if "interceptors" in kwargs:
                 # add our interceptor as the first
-                kwargs["interceptors"].insert(0, server_interceptor())
+                kwargs["interceptors"].insert(
+                    0, server_interceptor(tracer_provider=tracer_provider)
+                )
             else:
-                kwargs["interceptors"] = [server_interceptor()]
+                kwargs["interceptors"] = [
+                    server_interceptor(tracer_provider=tracer_provider)
+                ]
             return self._original_func(*args, **kwargs)
 
         grpc.server = server

instrumentation/opentelemetry-instrumentation-redis/src/opentelemetry/instrumentation/redis/__init__.py

@@ -113,13 +113,13 @@ class RedisInstrumentor(BaseInstrumentor):
     """
 
     def _instrument(self, **kwargs):
-        tracer_provider = kwargs.get(
-            "tracer_provider", trace.get_tracer_provider()
-        )
+        tracer_provider = kwargs.get("tracer_provider")
         setattr(
             redis,
             "_opentelemetry_tracer",
-            tracer_provider.get_tracer(_DEFAULT_SERVICE, __version__),
+            trace.get_tracer(
+                __name__, __version__, tracer_provider=tracer_provider,
+            ),
         )
 
         if redis.VERSION < (3, 0, 0):

instrumentation/opentelemetry-instrumentation-sqlalchemy/src/opentelemetry/instrumentation/sqlalchemy/engine.py

@@ -47,10 +47,10 @@ def _normalize_vendor(vendor):
 
 
 def _get_tracer(engine, tracer_provider=None):
-    if tracer_provider is None:
-        tracer_provider = trace.get_tracer_provider()
-    return tracer_provider.get_tracer(
-        _normalize_vendor(engine.name), __version__
+    return trace.get_tracer(
+        _normalize_vendor(engine.name),
+        __version__,
+        tracer_provider=tracer_provider,
     )
 
 

instrumentation/opentelemetry-instrumentation-starlette/src/opentelemetry/instrumentation/starlette/__init__.py

@@ -31,32 +31,37 @@ class StarletteInstrumentor(BaseInstrumentor):
     _original_starlette = None
 
     @staticmethod
-    def instrument_app(app: applications.Starlette):
+    def instrument_app(app: applications.Starlette, tracer_provider=None):
         """Instrument an uninstrumented Starlette application.
         """
         if not getattr(app, "is_instrumented_by_opentelemetry", False):
             app.add_middleware(
                 OpenTelemetryMiddleware,
                 excluded_urls=_excluded_urls,
                 span_details_callback=_get_route_details,
+                tracer_provider=tracer_provider,
             )
             app.is_instrumented_by_opentelemetry = True
 
     def _instrument(self, **kwargs):
         self._original_starlette = applications.Starlette
+        _InstrumentedStarlette._tracer_provider = kwargs.get("tracer_provider")
         applications.Starlette = _InstrumentedStarlette
 
     def _uninstrument(self, **kwargs):
         applications.Starlette = self._original_starlette
 
 
 class _InstrumentedStarlette(applications.Starlette):
+    _tracer_provider = None
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.add_middleware(
             OpenTelemetryMiddleware,
             excluded_urls=_excluded_urls,
             span_details_callback=_get_route_details,
+            tracer_provider=_InstrumentedStarlette._tracer_provider,
         )
 
 

instrumentation/opentelemetry-instrumentation-wsgi/src/opentelemetry/instrumentation/wsgi/__init__.py

@@ -192,9 +192,11 @@ class OpenTelemetryMiddleware:
                        Optional: Defaults to get_default_span_name.
     """
 
-    def __init__(self, wsgi, name_callback=get_default_span_name):
+    def __init__(
+        self, wsgi, name_callback=get_default_span_name, tracer_provider=None
+    ):
         self.wsgi = wsgi
-        self.tracer = trace.get_tracer(__name__, __version__)
+        self.tracer = trace.get_tracer(__name__, __version__, tracer_provider)
         self.name_callback = name_callback
 
     @staticmethod