Propagator Class [POC for review]

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

@@ -22,6 +22,8 @@
 
 from requests.sessions import Session
 
+from opentelemetry import propagator
+
 
 # NOTE: Currently we force passing a tracer. But in turn, this forces the user
 # to configure a SDK before enabling this integration. In turn, this means that
@@ -77,6 +79,10 @@ def instrumented_request(self, method, url, *args, **kwargs):
             span.set_attribute("http.status_code", result.status_code)
             span.set_attribute("http.status_text", result.reason)
 
+            propagator.global_propagator().inject(
+                result.headers.__setitem__, result.headers
+            )
+
             return result
 
         # TODO: How to handle exceptions? Should we create events for them? Set

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

@@ -2,16 +2,19 @@
 import unittest
 from unittest import mock
 
-import opentelemetry.ext.http_requests
 import requests
 import urllib3
-from opentelemetry import trace
+
+import opentelemetry.ext.http_requests
+from opentelemetry import propagator, trace
+from opentelemetry.context import Context
 
 
 class TestRequestsIntegration(unittest.TestCase):
 
     # TODO: Copy & paste from test_wsgi_middleware
     def setUp(self):
+        propagator.set_propagator(propagator.Propagator(Context, None, None))
         self.span_attrs = {}
         self.tracer = trace.tracer()
         self.span_context_manager = mock.MagicMock()

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

@@ -0,0 +1,109 @@
+# Copyright 2019, OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import typing
+
+from opentelemetry.context import BaseRuntimeContext
+
+from . import binaryformat, httptextformat
+
+
+class Propagator:
+    """Class which encapsulates propagation of values to and from context.
+
+    In contract to using the formatters directly, a propagator object can
+    help own configuration around which formatters to use, as well as
+    help simplify the work require for integrations to use the intended
+    formatters.
+    """
+
+    def __init__(
+        self,
+        context: BaseRuntimeContext,
+        httptextformat_instance: httptextformat.HTTPTextFormat,
+        binaryformat_instance: binaryformat.BinaryFormat,
+    ):
+        self._context = context
+        self._httptextformat = httptextformat_instance
+        self._binaryformat = binaryformat_instance
+
+    def extract(
+        self, get_from_carrier: httptextformat.Getter, carrier: object
+    ) -> None:
+        """Extract context data from the carrier, add to the context.
+
+        Using the http_format specified in the constructor, extract the
+        data form the carrier passed and add values into the context object.
+
+        Args:
+            get_from_carrier: a function that can retrieve zero
+                or more values from the carrier. In the case that
+                the value does not exist, return an empty list.
+            carrier: and object which contains values that are
+                used to construct a SpanContext. This object
+                must be paired with an appropriate get_from_carrier
+                which understands how to extract a value from it.
+        """
+
+    def inject(
+        self, set_in_carrier: httptextformat.Setter, carrier: object
+    ) -> None:
+        """Inject values from context into a carrier.
+
+        inject enables the propagation of values into HTTP clients or
+        other objects which perform an HTTP request. Using the
+        httptextformat configured, inject the context data into
+        the carrier with the set_in_carrier method passed.
+
+        Args:
+            set_in_carrier: A setter function that can set values
+                on the carrier.
+            carrier: An object that a place to define HTTP headers.
+                Should be paired with set_in_carrier, which should
+                know how to set header values on the carrier.
+        """
+
+    def from_bytes(self, byte_representation: bytes) -> None:
+        """Populate context with data that existed in the byte representation.
+
+        Using the configured binary_format, extract values from the bytes object
+        passed into the context object configured.
+
+        Args:
+            byte_representation: the bytes to deserialize.
+        """
+
+    def to_bytes(self) -> bytes:
+        """Creates a byte representation of the context configured.
+
+        to_bytes should read values from the configured context and
+        return a bytes object to represent it.
+
+        Returns:
+            A bytes representation of the DistributedContext.
+        """
+
+
+def set_propagator(propagator_instance: Propagator) -> None:
+    """Set the propagator instance singleton.
+    """
+    global _PROPAGATOR  # pylint:disable=global-statement
+    _PROPAGATOR = propagator_instance
+
+
+def global_propagator() -> typing.Optional[Propagator]:
+    """Return the singleton propagator instance."""
+    return _PROPAGATOR
+
+
+_PROPAGATOR = None  # type: typing.Optional[Propagator]

opentelemetry-api/src/opentelemetry/propagator/binaryformat.py

@@ -45,7 +45,7 @@ def to_bytes(context: BaseRuntimeContext) -> bytes:
     def from_bytes(
         context: BaseRuntimeContext, byte_representation: bytes
     ) -> None:
-        """Populate context with context data that existed in the byte representation.
+        """Populate context with data that existed in the byte representation.
 
         from_bytes should add values into the context from the data serialized in the
         byte_representation passed. If it is not possible to read in a proper

opentelemetry-api/tests/test_loader.py

@@ -12,13 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from importlib import reload
 import os
 import sys
 import unittest
+from importlib import reload
 
-from opentelemetry import loader
-from opentelemetry import trace
+from opentelemetry import loader, trace
 
 DUMMY_TRACER = None
 

opentelemetry-sdk/src/opentelemetry/sdk/propagator/__init__.py

@@ -0,0 +1,15 @@
+from opentelemetry.propagator import Propagator as PropagatorAPI
+
+
+class Propagator(PropagatorAPI):
+    def extract(self, get_from_carrier, carrier):
+        self._httptextformat.extract(self._context, get_from_carrier, carrier)
+
+    def inject(self, set_in_carrier, carrier):
+        self._httptextformat.inject(self._context, set_in_carrier, carrier)
+
+    def from_bytes(self, byte_representation):
+        self._binaryformat.from_bytes(self._context, byte_representation)
+
+    def to_bytes(self):
+        return self._binaryformat.to_bytes(self._context)

opentelemetry-sdk/tests/propagator/test_b3_format.py

@@ -13,11 +13,11 @@
 # limitations under the License.
 
 import unittest
-import opentelemetry.trace as api_trace
+
 import opentelemetry.context as context
 import opentelemetry.sdk.propagator.b3_format as b3_format
 import opentelemetry.sdk.trace as trace
-
+import opentelemetry.trace as api_trace
 from opentelemetry.sdk.trace import tracer
 
 FORMAT = b3_format.B3Format()

opentelemetry-sdk/tests/trace/test_trace.py

@@ -12,8 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from unittest import mock
 import unittest
+from unittest import mock
 
 from opentelemetry import trace as trace_api
 from opentelemetry.sdk import trace