microbootstrap 1.5.2__tar.gz → 1.5.4__tar.gz

{microbootstrap-1.5.2 → microbootstrap-1.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: microbootstrap
-Version: 1.5.2
+Version: 1.5.4
 Summary: Package for bootstrapping new micro-services
 Keywords: python,microservice,bootstrap,opentelemetry,logging,error-tracing,litestar,fastapi,fastmcp,mcp
 Author: community-of-python
@@ -528,6 +528,22 @@ Parameters description:
 
 These settings are subsequently passed to [opentelemetry](https://opentelemetry.io/), finalizing your Opentelemetry integration.
 
+If an authoritative baggage value becomes available only after the current span has started, pass the same mapping to
+`opentelemetry_baggage_scope` to also materialize that value on the already-started span:
+
+```python
+from microbootstrap import opentelemetry_baggage_scope
+
+
+with opentelemetry_baggage_scope(
+    {"conversation_id": conversation_id},
+    current_span_attributes=settings.opentelemetry_baggage_span_attributes,
+):
+    ...
+```
+
+Only non-`None` baggage values supplied to the scope and present in the mapping are added to a recording current span.
+
 #### FastStream
 
 For FastStream you also should pass `opentelemetry_middleware_cls` - OpenTelemetry middleware for your broker

{microbootstrap-1.5.2 → microbootstrap-1.5.4}/README.md

@@ -463,6 +463,22 @@ Parameters description:
 
 These settings are subsequently passed to [opentelemetry](https://opentelemetry.io/), finalizing your Opentelemetry integration.
 
+If an authoritative baggage value becomes available only after the current span has started, pass the same mapping to
+`opentelemetry_baggage_scope` to also materialize that value on the already-started span:
+
+```python
+from microbootstrap import opentelemetry_baggage_scope
+
+
+with opentelemetry_baggage_scope(
+    {"conversation_id": conversation_id},
+    current_span_attributes=settings.opentelemetry_baggage_span_attributes,
+):
+    ...
+```
+
+Only non-`None` baggage values supplied to the scope and present in the mapping are added to a recording current span.
+
 #### FastStream
 
 For FastStream you also should pass `opentelemetry_middleware_cls` - OpenTelemetry middleware for your broker

{microbootstrap-1.5.2 → microbootstrap-1.5.4}/microbootstrap/instruments/opentelemetry_instrument.py

@@ -17,10 +17,11 @@ from opentelemetry.sdk.trace import ReadableSpan, Span, SpanProcessor
 from opentelemetry.sdk.trace import TracerProvider as SdkTracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter, SimpleSpanProcessor
 from opentelemetry.semconv.resource import ResourceAttributes
-from opentelemetry.trace import SpanKind, format_span_id, set_tracer_provider
+from opentelemetry.trace import SpanKind, format_span_id, get_current_span, set_tracer_provider
 from opentelemetry.util._importlib_metadata import entry_points
 
 from microbootstrap.instruments.base import BaseInstrumentConfig, Instrument
+from microbootstrap.instruments.sentry_instrument import snapshot_sentry_opentelemetry_baggage
 
 
 LOGGER_OBJ: typing.Final = structlog.get_logger(__name__)
@@ -43,6 +44,8 @@ OpentelemetryConfigT = typing.TypeVar("OpentelemetryConfigT", bound="Opentelemet
 @contextlib.contextmanager
 def opentelemetry_baggage_scope(
     baggage_values: typing.Mapping[str, object | None],
+    *,
+    current_span_attributes: typing.Mapping[str, str] | None = None,
 ) -> typing.Iterator[None]:
     baggage_context = context.get_current()
     for key, value in baggage_values.items():
@@ -54,7 +57,15 @@ def opentelemetry_baggage_scope(
 
     token: typing.Final = context.attach(baggage_context)
     try:
+        if current_span_attributes and (current_span := get_current_span()).is_recording():
+            for baggage_key, span_attribute in current_span_attributes.items():
+                if baggage_key in baggage_values and (value := baggage_values[baggage_key]) is not None:
+                    current_span.set_attribute(span_attribute, str(value))
         yield
+    except Exception as exc:
+        with contextlib.suppress(Exception):
+            snapshot_sentry_opentelemetry_baggage(exc)
+        raise
     finally:
         context.detach(token)
 

{microbootstrap-1.5.2 → microbootstrap-1.5.4}/microbootstrap/instruments/sentry_instrument.py

@@ -3,13 +3,14 @@ import contextlib
 import functools
 import typing
 import urllib.parse
+from collections.abc import Mapping
 
 import orjson
 import pydantic
 import sentry_sdk
 from opentelemetry import baggage
 from sentry_sdk import _types as sentry_types
-from sentry_sdk.integrations import Integration  # noqa: TC002
+from sentry_sdk.integrations import Integration
 
 from microbootstrap.instruments.base import BaseInstrumentConfig, Instrument
 
@@ -66,6 +67,71 @@ def enrich_sentry_event_from_structlog_log(event: sentry_types.Event, _hint: sen
 
 SENTRY_EXTRA_OTEL_TRACE_ID_KEY: typing.Final = "otelTraceID"
 SENTRY_EXTRA_OTEL_TRACE_URL_KEY: typing.Final = "otelTraceURL"
+SENTRY_OTEL_BAGGAGE_SNAPSHOT_ATTRIBUTE: typing.Final = "__microbootstrap_sentry_opentelemetry_baggage__"
+
+
+@typing.final
+class SentryOpentelemetryBaggageIntegration(Integration):
+    identifier = "microbootstrap_opentelemetry_baggage"
+
+    def __init__(self, baggage_keys: set[str], baggage_url_templates: dict[str, str]) -> None:
+        self.baggage_keys: typing.Final = frozenset(baggage_keys)
+        self.baggage_url_templates: typing.Final = dict(baggage_url_templates)
+
+    @staticmethod
+    def setup_once() -> None:
+        pass
+
+
+def snapshot_sentry_opentelemetry_baggage(exception: BaseException) -> None:
+    integration = sentry_sdk.get_client().get_integration(SentryOpentelemetryBaggageIntegration)
+    if not isinstance(integration, SentryOpentelemetryBaggageIntegration) or hasattr(
+        exception,
+        SENTRY_OTEL_BAGGAGE_SNAPSHOT_ATTRIBUTE,
+    ):
+        return
+
+    configured_keys: typing.Final = integration.baggage_keys.union(integration.baggage_url_templates)
+    snapshot: typing.Final = {key: baggage.get_baggage(key) for key in configured_keys}
+    with contextlib.suppress(AttributeError, TypeError):
+        setattr(exception, SENTRY_OTEL_BAGGAGE_SNAPSHOT_ATTRIBUTE, snapshot)
+
+
+def _find_sentry_opentelemetry_baggage_snapshot(hint: sentry_types.Hint) -> Mapping[str, object | None] | None:
+    if not isinstance(hint, Mapping):
+        return None
+
+    exc_info: typing.Final = hint.get("exc_info")
+    if not isinstance(exc_info, tuple):
+        return None
+    try:
+        _, exception_value, _ = exc_info
+    except ValueError:
+        return None
+    if not isinstance(exception_value, BaseException):
+        return None
+
+    exceptions_to_visit: list[BaseException] = [exception_value]
+    visited_exceptions: set[int] = set()
+    while exceptions_to_visit:
+        exception = exceptions_to_visit.pop()
+        if id(exception) in visited_exceptions:
+            continue
+        visited_exceptions.add(id(exception))
+        exception_snapshot = getattr(exception, SENTRY_OTEL_BAGGAGE_SNAPSHOT_ATTRIBUTE, None)
+        if isinstance(exception_snapshot, Mapping):
+            return exception_snapshot
+
+        nested_exceptions = getattr(exception, "exceptions", ())
+        if isinstance(nested_exceptions, tuple):
+            exceptions_to_visit.extend(
+                reversed([nested for nested in nested_exceptions if isinstance(nested, BaseException)])
+            )
+        if chained_exception := exception.__cause__ or (
+            None if exception.__suppress_context__ else exception.__context__
+        ):
+            exceptions_to_visit.append(chained_exception)
+    return None
 
 
 def add_trace_url_to_event(
@@ -80,27 +146,30 @@ def enrich_sentry_event_from_opentelemetry_baggage(
     baggage_keys: set[str],
     baggage_url_templates: dict[str, str],
     event: sentry_types.Event,
-    _hint: sentry_types.Hint,
+    hint: sentry_types.Hint,
 ) -> sentry_types.Event:
-    baggage_values = {
-        key: value
-        for key in baggage_keys.union(baggage_url_templates)
-        if (value := baggage.get_baggage(key)) is not None
-    }
-    if not baggage_values:
-        return event
-
-    if tag_values := {key: str(baggage_values[key]) for key in baggage_keys if key in baggage_values}:
-        event.setdefault("tags", {}).update(tag_values)
+    configured_keys: typing.Final = baggage_keys.union(baggage_url_templates)
+    snapshot: typing.Final = _find_sentry_opentelemetry_baggage_snapshot(hint)
+    baggage_values: typing.Final = (
+        snapshot if snapshot is not None else {key: baggage.get_baggage(key) for key in configured_keys}
+    )
+
+    for key in baggage_keys:
+        if (value := baggage_values.get(key)) is not None:
+            event.setdefault("tags", {})[key] = str(value)
+        elif tags := event.get("tags"):
+            tags.pop(key, None)
 
     for key, url_template in baggage_url_templates.items():
         placeholder = f"{{{key}}}"
-        if key not in baggage_values or placeholder not in url_template:
-            continue
-        event.setdefault("extra", {})[f"{key}_url"] = url_template.replace(
-            placeholder,
-            urllib.parse.quote(str(baggage_values[key]), safe=""),
-        )
+        extra_key = f"{key}_url"
+        if (value := baggage_values.get(key)) is not None and placeholder in url_template:
+            event.setdefault("extra", {})[extra_key] = url_template.replace(
+                placeholder,
+                urllib.parse.quote(str(value), safe=""),
+            )
+        elif extra := event.get("extra"):
+            extra.pop(extra_key, None)
     return event
 
 
@@ -126,6 +195,17 @@ class SentryInstrument(Instrument[SentryConfig]):
         return bool(self.instrument_config.sentry_dsn)
 
     def bootstrap(self) -> None:
+        baggage_integration: typing.Final = (
+            SentryOpentelemetryBaggageIntegration(
+                self.instrument_config.sentry_opentelemetry_baggage_keys,
+                self.instrument_config.sentry_opentelemetry_baggage_url_templates,
+            )
+            if (
+                self.instrument_config.sentry_opentelemetry_baggage_keys
+                or self.instrument_config.sentry_opentelemetry_baggage_url_templates
+            )
+            else None
+        )
         sentry_sdk.init(
             dsn=self.instrument_config.sentry_dsn,
             sample_rate=self.instrument_config.sentry_sample_rate,
@@ -153,7 +233,10 @@ class SentryInstrument(Instrument[SentryConfig]):
                 else None,
                 self.instrument_config.sentry_before_send,
             ),
-            integrations=self.instrument_config.sentry_integrations,
+            integrations=[
+                *self.instrument_config.sentry_integrations,
+                *([baggage_integration] if baggage_integration else []),
+            ],
             **self.instrument_config.sentry_additional_params,
         )
         if self.instrument_config.sentry_tags:

{microbootstrap-1.5.2 → microbootstrap-1.5.4}/pyproject.toml

@@ -58,7 +58,7 @@ dependencies = [
     "opentelemetry-instrumentation-asgi>=0.46b0",
     "orjson>=3.10.18",
 ]
-version = "1.5.2"
+version = "1.5.4"
 
 [[project.authors]]
 name = "community-of-python"

{microbootstrap-1.5.2 → microbootstrap-1.5.4}/pyproject.toml.orig

@@ -58,7 +58,7 @@ dependencies = [
     "opentelemetry-instrumentation-asgi>=0.46b0",
     "orjson>=3.10.18",
 ]
-version = "1.5.2"
+version = "1.5.4"
 authors = [{ name = "community-of-python" }]
 
 [project.optional-dependencies]