Named tracers

examples/basic_tracer/tracer.py

@@ -18,7 +18,7 @@
 
 from opentelemetry import trace
 from opentelemetry.context import Context
-from opentelemetry.sdk.trace import Tracer
+from opentelemetry.sdk.trace import TracerSource
 from opentelemetry.sdk.trace.export import (
     BatchExportSpanProcessor,
     ConsoleSpanExporter,
@@ -37,13 +37,19 @@
 
 # The preferred tracer implementation must be set, as the opentelemetry-api
 # defines the interface with a no-op implementation.
-trace.set_preferred_tracer_implementation(lambda T: Tracer())
-tracer = trace.tracer()
+trace.set_preferred_tracer_source_implementation(lambda T: TracerSource())
+
+# We tell OpenTelemetry who it is that is creating spans. In this case, we have
+# no real name (no setup.py), so we make one up. If we had a version, we would
+# also specify it here.
+tracer = trace.tracer_source().get_tracer(
+    "opentelemetry-examples-basic-tracer"
+)
 
 # SpanExporter receives the spans and send them to the target location.
 span_processor = BatchExportSpanProcessor(exporter)
 
-tracer.add_span_processor(span_processor)
+trace.tracer_source().add_span_processor(span_processor)
 with tracer.start_as_current_span("foo"):
     with tracer.start_as_current_span("bar"):
         with tracer.start_as_current_span("baz"):

examples/http/server.py

@@ -22,7 +22,7 @@
 from opentelemetry import trace
 from opentelemetry.ext import http_requests
 from opentelemetry.ext.wsgi import OpenTelemetryMiddleware
-from opentelemetry.sdk.trace import Tracer
+from opentelemetry.sdk.trace import TracerSource
 from opentelemetry.sdk.trace.export import (
     BatchExportSpanProcessor,
     ConsoleSpanExporter,
@@ -41,17 +41,17 @@
 
 # The preferred tracer implementation must be set, as the opentelemetry-api
 # defines the interface with a no-op implementation.
-trace.set_preferred_tracer_implementation(lambda T: Tracer())
-tracer = trace.tracer()
+trace.set_preferred_tracer_source_implementation(lambda T: TracerSource())
+tracer = trace.tracer_source().get_tracer("opentelemetry-example-http")
 
 # SpanExporter receives the spans and send them to the target location.
 span_processor = BatchExportSpanProcessor(exporter)
-tracer.add_span_processor(span_processor)
+trace.tracer_source().add_span_processor(span_processor)
 
 # Integrations are the glue that binds the OpenTelemetry API and the
 # frameworks and libraries that are used together, automatically creating
 # Spans and propagating context as appropriate.
-http_requests.enable(tracer)
+http_requests.enable(trace.tracer_source())
 app = flask.Flask(__name__)
 app.wsgi_app = OpenTelemetryMiddleware(app.wsgi_app)
 

examples/http/tracer_client.py

@@ -20,7 +20,7 @@
 
 from opentelemetry import trace
 from opentelemetry.ext import http_requests
-from opentelemetry.sdk.trace import Tracer
+from opentelemetry.sdk.trace import TracerSource
 from opentelemetry.sdk.trace.export import (
     BatchExportSpanProcessor,
     ConsoleSpanExporter,
@@ -39,15 +39,15 @@
 
 # The preferred tracer implementation must be set, as the opentelemetry-api
 # defines the interface with a no-op implementation.
-trace.set_preferred_tracer_implementation(lambda T: Tracer())
-tracer = trace.tracer()
+trace.set_preferred_tracer_source_implementation(lambda T: TracerSource())
+tracer_source = trace.tracer_source()
 
 # SpanExporter receives the spans and send them to the target location.
 span_processor = BatchExportSpanProcessor(exporter)
-tracer.add_span_processor(span_processor)
+tracer_source.add_span_processor(span_processor)
 
 # Integrations are the glue that binds the OpenTelemetry API and the
 # frameworks and libraries that are used together, automatically creating
 # Spans and propagating context as appropriate.
-http_requests.enable(tracer)
+http_requests.enable(tracer_source)
 response = requests.get(url="http://127.0.0.1:5000/")

examples/opentelemetry-example-app/src/opentelemetry_example_app/flask_example.py

@@ -17,13 +17,14 @@
 the requests library to perform downstream requests
 """
 import flask
+import pkg_resources
 import requests
 
 import opentelemetry.ext.http_requests
 from opentelemetry import propagators, trace
 from opentelemetry.ext.flask import instrument_app
 from opentelemetry.sdk.context.propagation.b3_format import B3Format
-from opentelemetry.sdk.trace import Tracer
+from opentelemetry.sdk.trace import TracerSource
 
 
 def configure_opentelemetry(flask_app: flask.Flask):
@@ -45,7 +46,7 @@ def configure_opentelemetry(flask_app: flask.Flask):
     # the preferred implementation of these objects must be set,
     # as the opentelemetry-api defines the interface with a no-op
     # implementation.
-    trace.set_preferred_tracer_implementation(lambda _: Tracer())
+    trace.set_preferred_tracer_source_implementation(lambda _: TracerSource())
     # Next, we need to configure how the values that are used by
     # traces and metrics are propagated (such as what specific headers
     # carry this value).
@@ -56,7 +57,7 @@ def configure_opentelemetry(flask_app: flask.Flask):
     # Integrations are the glue that binds the OpenTelemetry API
     # and the frameworks and libraries that are used together, automatically
     # creating Spans and propagating context as appropriate.
-    opentelemetry.ext.http_requests.enable(trace.tracer())
+    opentelemetry.ext.http_requests.enable(trace.tracer_source())
     instrument_app(flask_app)
 
 
@@ -67,7 +68,13 @@ def configure_opentelemetry(flask_app: flask.Flask):
 def hello():
     # emit a trace that measures how long the
     # sleep takes
-    with trace.tracer().start_as_current_span("example-request"):
+    version = pkg_resources.get_distribution(
+        "opentelemetry-example-app"
+    ).version
+    tracer = trace.tracer_source().get_tracer(
+        "opentelemetry-example-app", version
+    )
+    with tracer.start_as_current_span("example-request"):
         requests.get("http://www.example.com")
     return "hello"
 

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

@@ -7,6 +7,7 @@
 
 import opentelemetry.ext.wsgi as otel_wsgi
 from opentelemetry import propagators, trace
+from opentelemetry.ext.flask.version import __version__
 from opentelemetry.util import time_ns
 
 logger = logging.getLogger(__name__)
@@ -60,7 +61,9 @@ def _before_flask_request():
         otel_wsgi.get_header_from_environ, environ
     )
 
-    tracer = trace.tracer()
+    tracer = trace.tracer_source().get_tracer(
+        "opentelemetry-ext-flask", __version__
+    )
 
     span = tracer.start_span(
         span_name,

ext/opentelemetry-ext-http-requests/src/opentelemetry/ext/http_requests/__init__.py

@@ -24,6 +24,7 @@
 
 from opentelemetry import propagators
 from opentelemetry.context import Context
+from opentelemetry.ext.http_requests.version import __version__
 from opentelemetry.trace import SpanKind
 
 
@@ -32,7 +33,7 @@
 # if the SDK/tracer is already using `requests` they may, in theory, bypass our
 # instrumentation when using `import from`, etc. (currently we only instrument
 # a instance method so the probability for that is very low).
-def enable(tracer):
+def enable(tracer_source):
     """Enables tracing of all requests calls that go through
       :code:`requests.session.Session.request` (this includes
       :code:`requests.get`, etc.)."""
@@ -47,6 +48,10 @@ def enable(tracer):
     # Guard against double instrumentation
     disable()
 
+    tracer = tracer_source.get_tracer(
+        "opentelemetry-ext-http-requests", __version__
+    )
+
     wrapped = Session.request
 
     @functools.wraps(wrapped)

ext/opentelemetry-ext-http-requests/tests/test_requests_integration.py

@@ -16,6 +16,7 @@
 import unittest
 from unittest import mock
 
+import pkg_resources
 import requests
 import urllib3
 
@@ -28,7 +29,16 @@ class TestRequestsIntegration(unittest.TestCase):
     # TODO: Copy & paste from test_wsgi_middleware
     def setUp(self):
         self.span_attrs = {}
-        self.tracer = trace.tracer()
+        self.tracer_source = trace.TracerSource()
+        self.tracer = trace.Tracer()
+        self.get_tracer_patcher = mock.patch.object(
+            self.tracer_source,
+            "get_tracer",
+            autospec=True,
+            spec_set=True,
+            return_value=self.tracer,
+        )
+        self.get_tracer = self.get_tracer_patcher.start()
         self.span_context_manager = mock.MagicMock()
         self.span = mock.create_autospec(trace.Span, spec_set=True)
         self.span_context_manager.__enter__.return_value = self.span
@@ -59,18 +69,25 @@ def setspanattr(key, value):
         )
         self.send = self.send_patcher.start()
 
-        opentelemetry.ext.http_requests.enable(self.tracer)
+        opentelemetry.ext.http_requests.enable(self.tracer_source)
+        distver = pkg_resources.get_distribution(
+            "opentelemetry-ext-http-requests"
+        ).version
+        self.get_tracer.assert_called_with(
+            "opentelemetry-ext-http-requests", distver
+        )
 
     def tearDown(self):
         opentelemetry.ext.http_requests.disable()
+        self.get_tracer_patcher.stop()
         self.send_patcher.stop()
         self.start_span_patcher.stop()
 
     def test_basic(self):
         url = "https://www.example.org/foo/bar?x=y#top"
         requests.get(url=url)
         self.assertEqual(1, len(self.send.call_args_list))
-        self.tracer.start_as_current_span.assert_called_with(
+        self.tracer.start_as_current_span.assert_called_with(  # pylint:disable=no-member
             "/foo/bar", kind=trace.SpanKind.CLIENT
         )
         self.span_context_manager.__enter__.assert_called_with()
@@ -96,11 +113,12 @@ def test_invalid_url(self):
 
         with self.assertRaises(exception_type):
             requests.post(url=url)
+        call_args = (
+            self.tracer.start_as_current_span.call_args  # pylint:disable=no-member
+        )
         self.assertTrue(
-            self.tracer.start_as_current_span.call_args[0][0].startswith(
-                "<Unparsable URL"
-            ),
-            msg=self.tracer.start_as_current_span.call_args,
+            call_args[0][0].startswith("<Unparsable URL"),
+            msg=self.tracer.start_as_current_span.call_args,  # pylint:disable=no-member
         )
         self.span_context_manager.__enter__.assert_called_with()
         exitspan = self.span_context_manager.__exit__

ext/opentelemetry-ext-opentracing-shim/src/opentelemetry/ext/opentracing_shim/__init__.py

@@ -86,28 +86,33 @@
 import opentelemetry.trace as trace_api
 from opentelemetry import propagators
 from opentelemetry.ext.opentracing_shim import util
+from opentelemetry.ext.opentracing_shim.version import __version__
 
 logger = logging.getLogger(__name__)
 
 
-def create_tracer(otel_tracer):
+def create_tracer(otel_tracer_source):
     """Creates a :class:`TracerShim` object from the provided OpenTelemetry
-    :class:`opentelemetry.trace.Tracer`.
+    :class:`opentelemetry.trace.TracerSource`.
 
     The returned :class:`TracerShim` is an implementation of
     :class:`opentracing.Tracer` using OpenTelemetry under the hood.
 
     Args:
-        otel_tracer: A :class:`opentelemetry.trace.Tracer` to be used for
-            constructing the :class:`TracerShim`. This tracer will be used
+        otel_tracer_source: A :class:`opentelemetry.trace.TracerSource` to be used for
+            constructing the :class:`TracerShim`. A tracer from this source will be used
             to perform the actual tracing when user code is instrumented using
             the OpenTracing API.
 
     Returns:
         The created :class:`TracerShim`.
     """
 
-    return TracerShim(otel_tracer)
+    return TracerShim(
+        otel_tracer_source.get_tracer(
+            "opentelemetry-ext-opentracing-shim", __version__
+        )
+    )
 
 
 class SpanContextShim(opentracing.SpanContext):

ext/opentelemetry-ext-opentracing-shim/tests/test_shim.py

@@ -21,7 +21,7 @@
 from opentelemetry import propagators, trace
 from opentelemetry.context.propagation.httptextformat import HTTPTextFormat
 from opentelemetry.ext.opentracing_shim import util
-from opentelemetry.sdk.trace import Tracer
+from opentelemetry.sdk.trace import TracerSource
 
 
 class TestShim(unittest.TestCase):
@@ -30,16 +30,17 @@ class TestShim(unittest.TestCase):
     def setUp(self):
         """Create an OpenTelemetry tracer and a shim before every test case."""
 
-        self.tracer = trace.tracer()
-        self.shim = opentracingshim.create_tracer(self.tracer)
+        self.shim = opentracingshim.create_tracer(trace.tracer_source())
 
     @classmethod
     def setUpClass(cls):
         """Set preferred tracer implementation only once rather than before
         every test method.
         """
 
-        trace.set_preferred_tracer_implementation(lambda T: Tracer())
+        trace.set_preferred_tracer_source_implementation(
+            lambda T: TracerSource()
+        )
 
         # Save current propagator to be restored on teardown.
         cls._previous_propagator = propagators.get_global_httptextformat()

ext/opentelemetry-ext-testutil/src/opentelemetry/ext/testutil/wsgitestutil.py

@@ -8,8 +8,17 @@
 
 class WsgiTestBase(unittest.TestCase):
     def setUp(self):
-        tracer = trace_api.tracer()
         self.span = mock.create_autospec(trace_api.Span, spec_set=True)
+        tracer = trace_api.Tracer()
+        self.get_tracer_patcher = mock.patch.object(
+            trace_api.TracerSource,
+            "get_tracer",
+            autospec=True,
+            spec_set=True,
+            return_value=tracer,
+        )
+        self.get_tracer_patcher.start()
+
         self.start_span_patcher = mock.patch.object(
             tracer,
             "start_span",
@@ -29,6 +38,7 @@ def setUp(self):
         self.exc_info = None
 
     def tearDown(self):
+        self.get_tracer_patcher.stop()
         self.start_span_patcher.stop()
 
     def start_response(self, status, response_headers, exc_info=None):