diff options
Diffstat (limited to '.venv/lib/python3.12/site-packages/opentelemetry/baggage')
3 files changed, 278 insertions, 0 deletions
diff --git a/.venv/lib/python3.12/site-packages/opentelemetry/baggage/__init__.py b/.venv/lib/python3.12/site-packages/opentelemetry/baggage/__init__.py new file mode 100644 index 00000000..9a740200 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/opentelemetry/baggage/__init__.py @@ -0,0 +1,132 @@ +# Copyright The 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. + +from logging import getLogger +from re import compile +from types import MappingProxyType +from typing import Mapping, Optional + +from opentelemetry.context import create_key, get_value, set_value +from opentelemetry.context.context import Context +from opentelemetry.util.re import ( + _BAGGAGE_PROPERTY_FORMAT, + _KEY_FORMAT, + _VALUE_FORMAT, +) + +_BAGGAGE_KEY = create_key("baggage") +_logger = getLogger(__name__) + +_KEY_PATTERN = compile(_KEY_FORMAT) +_VALUE_PATTERN = compile(_VALUE_FORMAT) +_PROPERT_PATTERN = compile(_BAGGAGE_PROPERTY_FORMAT) + + +def get_all( + context: Optional[Context] = None, +) -> Mapping[str, object]: + """Returns the name/value pairs in the Baggage + + Args: + context: The Context to use. If not set, uses current Context + + Returns: + The name/value pairs in the Baggage + """ + baggage = get_value(_BAGGAGE_KEY, context=context) + if isinstance(baggage, dict): + return MappingProxyType(baggage) + return MappingProxyType({}) + + +def get_baggage( + name: str, context: Optional[Context] = None +) -> Optional[object]: + """Provides access to the value for a name/value pair in the + Baggage + + Args: + name: The name of the value to retrieve + context: The Context to use. If not set, uses current Context + + Returns: + The value associated with the given name, or null if the given name is + not present. + """ + return get_all(context=context).get(name) + + +def set_baggage( + name: str, value: object, context: Optional[Context] = None +) -> Context: + """Sets a value in the Baggage + + Args: + name: The name of the value to set + value: The value to set + context: The Context to use. If not set, uses current Context + + Returns: + A Context with the value updated + """ + baggage = dict(get_all(context=context)) + baggage[name] = value + return set_value(_BAGGAGE_KEY, baggage, context=context) + + +def remove_baggage(name: str, context: Optional[Context] = None) -> Context: + """Removes a value from the Baggage + + Args: + name: The name of the value to remove + context: The Context to use. If not set, uses current Context + + Returns: + A Context with the name/value removed + """ + baggage = dict(get_all(context=context)) + baggage.pop(name, None) + + return set_value(_BAGGAGE_KEY, baggage, context=context) + + +def clear(context: Optional[Context] = None) -> Context: + """Removes all values from the Baggage + + Args: + context: The Context to use. If not set, uses current Context + + Returns: + A Context with all baggage entries removed + """ + return set_value(_BAGGAGE_KEY, {}, context=context) + + +def _is_valid_key(name: str) -> bool: + return _KEY_PATTERN.fullmatch(str(name)) is not None + + +def _is_valid_value(value: object) -> bool: + parts = str(value).split(";") + is_valid_value = _VALUE_PATTERN.fullmatch(parts[0]) is not None + if len(parts) > 1: # one or more properties metadata + for property in parts[1:]: + if _PROPERT_PATTERN.fullmatch(property) is None: + is_valid_value = False + break + return is_valid_value + + +def _is_valid_pair(key: str, value: str) -> bool: + return _is_valid_key(key) and _is_valid_value(value) diff --git a/.venv/lib/python3.12/site-packages/opentelemetry/baggage/propagation/__init__.py b/.venv/lib/python3.12/site-packages/opentelemetry/baggage/propagation/__init__.py new file mode 100644 index 00000000..49fb378e --- /dev/null +++ b/.venv/lib/python3.12/site-packages/opentelemetry/baggage/propagation/__init__.py @@ -0,0 +1,146 @@ +# Copyright The 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. +# +from logging import getLogger +from re import split +from typing import Iterable, List, Mapping, Optional, Set +from urllib.parse import quote_plus, unquote_plus + +from opentelemetry.baggage import _is_valid_pair, get_all, set_baggage +from opentelemetry.context import get_current +from opentelemetry.context.context import Context +from opentelemetry.propagators import textmap +from opentelemetry.util.re import _DELIMITER_PATTERN + +_logger = getLogger(__name__) + + +class W3CBaggagePropagator(textmap.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" + + def extract( + self, + carrier: textmap.CarrierT, + context: Optional[Context] = None, + getter: textmap.Getter[textmap.CarrierT] = textmap.default_getter, + ) -> Context: + """Extract Baggage from the carrier. + + See + `opentelemetry.propagators.textmap.TextMapPropagator.extract` + """ + + if context is None: + context = get_current() + + header = _extract_first_element( + getter.get(carrier, self._BAGGAGE_HEADER_NAME) + ) + + if not header: + return context + + if len(header) > self._MAX_HEADER_LENGTH: + _logger.warning( + "Baggage header `%s` exceeded the maximum number of bytes per baggage-string", + header, + ) + return context + + baggage_entries: List[str] = split(_DELIMITER_PATTERN, header) + total_baggage_entries = self._MAX_PAIRS + + if len(baggage_entries) > self._MAX_PAIRS: + _logger.warning( + "Baggage header `%s` exceeded the maximum number of list-members", + header, + ) + + for entry in baggage_entries: + if len(entry) > self._MAX_PAIR_LENGTH: + _logger.warning( + "Baggage entry `%s` exceeded the maximum number of bytes per list-member", + entry, + ) + continue + if not entry: # empty string + continue + try: + name, value = entry.split("=", 1) + except Exception: # pylint: disable=broad-exception-caught + _logger.warning( + "Baggage list-member `%s` doesn't match the format", entry + ) + continue + + if not _is_valid_pair(name, value): + _logger.warning("Invalid baggage entry: `%s`", entry) + continue + + name = unquote_plus(name).strip() + value = unquote_plus(value).strip() + + context = set_baggage( + name, + value, + context=context, + ) + total_baggage_entries -= 1 + if total_baggage_entries == 0: + break + + return context + + def inject( + self, + carrier: textmap.CarrierT, + context: Optional[Context] = None, + setter: textmap.Setter[textmap.CarrierT] = textmap.default_setter, + ) -> None: + """Injects Baggage into the carrier. + + See + `opentelemetry.propagators.textmap.TextMapPropagator.inject` + """ + baggage_entries = get_all(context=context) + if not baggage_entries: + return + + baggage_string = _format_baggage(baggage_entries) + setter.set(carrier, self._BAGGAGE_HEADER_NAME, baggage_string) + + @property + def fields(self) -> Set[str]: + """Returns a set with the fields set in `inject`.""" + return {self._BAGGAGE_HEADER_NAME} + + +def _format_baggage(baggage_entries: Mapping[str, object]) -> str: + return ",".join( + quote_plus(str(key)) + "=" + quote_plus(str(value)) + for key, value in baggage_entries.items() + ) + + +def _extract_first_element( + items: Optional[Iterable[textmap.CarrierT]], +) -> Optional[textmap.CarrierT]: + if items is None: + return None + return next(iter(items), None) diff --git a/.venv/lib/python3.12/site-packages/opentelemetry/baggage/py.typed b/.venv/lib/python3.12/site-packages/opentelemetry/baggage/py.typed new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/.venv/lib/python3.12/site-packages/opentelemetry/baggage/py.typed |