Remove setters and getters

Fixes open-telemetry#1644

Author: ocelotl

opentelemetry-api/src/opentelemetry/baggage/propagation/__init__.py

@@ -11,29 +11,27 @@
 # 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
-import urllib.parse
+
+from typing import Optional, Set
+from urllib.parse import unquote, quote_plus
 
 from opentelemetry import baggage
 from opentelemetry.context import get_current
 from opentelemetry.context.context import Context
-from opentelemetry.propagators import textmap
+from opentelemetry.propagators.textmap import (
+    TextMapPropagator, TextMapPropagatorT
+)
 
 
-class W3CBaggagePropagator(textmap.TextMapPropagator):
+class W3CBaggagePropagator(TextMapPropagator):
     """Extracts and injects Baggage which is used to annotate telemetry."""
 
-    _MAX_HEADER_LENGTH = 8192
-    _MAX_PAIR_LENGTH = 4096
-    _MAX_PAIRS = 180
-    _BAGGAGE_HEADER_NAME = "baggage"
+    _baggage_header_name = "baggage"
 
     def extract(
         self,
-        getter: textmap.Getter[textmap.TextMapPropagatorT],
-        carrier: textmap.TextMapPropagatorT,
-        context: typing.Optional[Context] = None,
+        carrier: TextMapPropagatorT,
+        context: Optional[Context] = None,
     ) -> Context:
         """Extract Baggage from the carrier.
 
@@ -44,67 +42,56 @@ def extract(
         if context is None:
             context = get_current()
 
-        header = _extract_first_element(
-            getter.get(carrier, self._BAGGAGE_HEADER_NAME)
-        )
+        value = carrier.get(self._baggage_header_name)
+
+        if value is None:
+            header = None
+        else:
+            header = next(iter(value), None)
 
-        if not header or len(header) > self._MAX_HEADER_LENGTH:
+        # 8192 is the maximum header length
+        if header is None or len(header) > 8192:
             return context
 
-        baggage_entries = header.split(",")
-        total_baggage_entries = self._MAX_PAIRS
-        for entry in baggage_entries:
+        # 180 is the maximum amount of pairs
+        total_baggage_entries = 180
+
+        for entry in header.split(","):
             if total_baggage_entries <= 0:
                 return context
             total_baggage_entries -= 1
-            if len(entry) > self._MAX_PAIR_LENGTH:
+            # 4096 is the maximum pair length
+            if len(entry) > 4096:
                 continue
-            try:
+            if "=" in entry:
                 name, value = entry.split("=", 1)
-            except Exception:  # pylint: disable=broad-except
-                continue
-            context = baggage.set_baggage(
-                urllib.parse.unquote(name).strip(),
-                urllib.parse.unquote(value).strip(),
-                context=context,
-            )
+                context = baggage.set_baggage(
+                    unquote(name).strip(),
+                    unquote(value).strip(),
+                    context=context,
+                )
 
         return context
 
     def inject(
         self,
-        set_in_carrier: textmap.Setter[textmap.TextMapPropagatorT],
-        carrier: textmap.TextMapPropagatorT,
-        context: typing.Optional[Context] = None,
+        carrier: TextMapPropagatorT,
+        context: Optional[Context] = None,
     ) -> None:
         """Injects Baggage into the carrier.
 
         See
         `opentelemetry.propagators.textmap.TextMapPropagator.inject`
         """
         baggage_entries = baggage.get_all(context=context)
-        if not baggage_entries:
-            return
 
-        baggage_string = _format_baggage(baggage_entries)
-        set_in_carrier(carrier, self._BAGGAGE_HEADER_NAME, baggage_string)
+        if baggage_entries:
+            carrier[self._baggage_header_name] = ",".join(
+                key + "=" + quote_plus(str(value))
+                for key, value in baggage_entries.items()
+            )
 
     @property
-    def fields(self) -> typing.Set[str]:
+    def fields(self) -> Set[str]:
         """Returns a set with the fields set in `inject`."""
-        return {self._BAGGAGE_HEADER_NAME}
-
-
-def _format_baggage(baggage_entries: typing.Mapping[str, object]) -> str:
-    return ",".join(
-        key + "=" + urllib.parse.quote_plus(str(value))
-        for key, value in baggage_entries.items()
-    )
-
-
-def _extract_first_element(
-    items: typing.Optional[typing.Iterable[textmap.TextMapPropagatorT]],
-) -> typing.Optional[textmap.TextMapPropagatorT]:
-    if items is None:
-        return None
-    return next(iter(items), None)
+        return {self._baggage_header_name}

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

@@ -40,23 +40,12 @@
     PROPAGATOR = propagators.get_global_textmap()
 
 
-    def get_header_from_flask_request(request, key):
-        return request.headers.get_all(key)
-
-    def set_header_into_requests_request(request: requests.Request,
-                                            key: str, value: str):
-        request.headers[key] = value
-
     def example_route():
-        context = PROPAGATOR.extract(
-            get_header_from_flask_request,
-            flask.request
-        )
+        context = PROPAGATOR.extract(flask.request)
         request_to_downstream = requests.Request(
             "GET", "http://httpbin.org/get"
         )
         PROPAGATOR.inject(
-            set_header_into_requests_request,
             request_to_downstream,
             context=context
         )
@@ -68,23 +57,26 @@ def example_route():
     https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/context/api-propagators.md
 """
 
-import typing
+from typing import Optional
 from logging import getLogger
 from os import environ
 
 from pkg_resources import iter_entry_points
 
 from opentelemetry.context.context import Context
 from opentelemetry.environment_variables import OTEL_PROPAGATORS
-from opentelemetry.propagators import composite, textmap
+from opentelemetry.propagators import composite
+from opentelemetry.propagators.textmap import (
+    TextMapPropagator, TextMapPropagatorT
+)
+
 
-logger = getLogger(__name__)
+_logger = getLogger(__name__)
 
 
 def extract(
-    getter: textmap.Getter[textmap.TextMapPropagatorT],
-    carrier: textmap.TextMapPropagatorT,
-    context: typing.Optional[Context] = None,
+    carrier: TextMapPropagatorT,
+    context: Optional[Context] = None,
 ) -> Context:
     """Uses the configured propagator to extract a Context from the carrier.
 
@@ -99,26 +91,22 @@ def extract(
         context: an optional Context to use. Defaults to current
             context if not set.
     """
-    return get_global_textmap().extract(getter, carrier, context)
+    return get_global_textmap().extract(carrier, context)
 
 
 def inject(
-    set_in_carrier: textmap.Setter[textmap.TextMapPropagatorT],
-    carrier: textmap.TextMapPropagatorT,
-    context: typing.Optional[Context] = None,
+    carrier: TextMapPropagatorT,
+    context: Optional[Context] = None,
 ) -> None:
     """Uses the configured propagator to inject a Context into the carrier.
 
     Args:
-        set_in_carrier: A setter function that can set values
-            on the carrier.
-        carrier: An object that contains a representation of HTTP
-            headers. Should be paired with set_in_carrier, which
-            should know how to set header values on the carrier.
+        carrier: A dict-like object that contains a representation of HTTP
+            headers.
         context: an optional Context to use. Defaults to current
             context if not set.
     """
-    get_global_textmap().inject(set_in_carrier, carrier, context)
+    get_global_textmap().inject(carrier, context)
 
 
 try:
@@ -138,16 +126,16 @@ def inject(
         )
 
 except Exception:  # pylint: disable=broad-except
-    logger.exception("Failed to load configured propagators")
+    _logger.error("Failed to load configured propagators")
     raise
 
-_HTTP_TEXT_FORMAT = composite.CompositeHTTPPropagator(propagators)  # type: ignore
+_textmap_propagator = composite.CompositeHTTPPropagator(propagators)  # type: ignore
 
 
-def get_global_textmap() -> textmap.TextMapPropagator:
-    return _HTTP_TEXT_FORMAT
+def get_global_textmap() -> TextMapPropagator:
+    return _textmap_propagator
 
 
-def set_global_textmap(http_text_format: textmap.TextMapPropagator,) -> None:
-    global _HTTP_TEXT_FORMAT  # pylint:disable=global-statement
-    _HTTP_TEXT_FORMAT = http_text_format  # type: ignore
+def set_global_textmap(http_text_format: TextMapPropagator,) -> None:
+    global _textmap_propagator  # pylint:disable=global-statement
+    _textmap_propagator = http_text_format  # type: ignore

opentelemetry-api/src/opentelemetry/propagators/composite.py

@@ -11,16 +11,19 @@
 # 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 logging
-import typing
+
+from logging import getLogger
+from typing import Optional, Set, Sequence
 
 from opentelemetry.context.context import Context
-from opentelemetry.propagators import textmap
+from opentelemetry.propagators.textmap import (
+    TextMapPropagator, TextMapPropagatorT
+)
 
-logger = logging.getLogger(__name__)
+_logger = getLogger(__name__)
 
 
-class CompositeHTTPPropagator(textmap.TextMapPropagator):
+class CompositeHTTPPropagator(TextMapPropagator):
     """CompositeHTTPPropagator provides a mechanism for combining multiple
     propagators into a single one.
 
@@ -29,45 +32,44 @@ class CompositeHTTPPropagator(textmap.TextMapPropagator):
     """
 
     def __init__(
-        self, propagators: typing.Sequence[textmap.TextMapPropagator]
+        self, propagators: Sequence[TextMapPropagator]
     ) -> None:
         self._propagators = propagators
 
     def extract(
         self,
-        getter: textmap.Getter[textmap.TextMapPropagatorT],
-        carrier: textmap.TextMapPropagatorT,
-        context: typing.Optional[Context] = None,
+        carrier: TextMapPropagatorT,
+        context: Optional[Context] = None,
     ) -> Context:
-        """Run each of the configured propagators with the given context and carrier.
+        """Run each of the configured propagators with the given context and
+        carrier.
         Propagators are run in the order they are configured, if multiple
-        propagators write the same context key, the propagator later in the list
-        will override previous propagators.
+        propagators write the same context key, the last propagator that writes
+        the context key will override previous propagators.
 
         See `opentelemetry.propagators.textmap.TextMapPropagator.extract`
         """
         for propagator in self._propagators:
-            context = propagator.extract(getter, carrier, context)
+            context = propagator.extract(carrier, context)
         return context  # type: ignore
 
     def inject(
         self,
-        set_in_carrier: textmap.Setter[textmap.TextMapPropagatorT],
-        carrier: textmap.TextMapPropagatorT,
-        context: typing.Optional[Context] = None,
+        carrier: TextMapPropagatorT,
+        context: Optional[Context] = None,
     ) -> None:
-        """Run each of the configured propagators with the given context and carrier.
-        Propagators are run in the order they are configured, if multiple
-        propagators write the same carrier key, the propagator later in the list
-        will override previous propagators.
+        """Run each of the configured propagators with the given context and
+        carrier. Propagators are run in the order they are configured, if
+        multiple propagators write the same carrier key, the last propagator
+        that writes the carrier key will override previous propagators.
 
         See `opentelemetry.propagators.textmap.TextMapPropagator.inject`
         """
         for propagator in self._propagators:
-            propagator.inject(set_in_carrier, carrier, context)
+            propagator.inject(carrier, context)
 
     @property
-    def fields(self) -> typing.Set[str]:
+    def fields(self) -> Set[str]:
         """Returns a set with the fields set in `inject`.
 
         See