sentry-sdk 2.69.0__tar.gz → 2.69.2__tar.gz

{sentry_sdk-2.69.0/sentry_sdk.egg-info → sentry_sdk-2.69.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry-sdk
-Version: 2.69.0
+Version: 2.69.2
 Summary: Python client for Sentry (https://sentry.io)
 Home-page: https://github.com/getsentry/sentry-python
 Author: Sentry Team and Contributors

{sentry_sdk-2.69.0 → sentry_sdk-2.69.2}/sentry_sdk/client.py

@@ -42,7 +42,8 @@ from sentry_sdk.scrubber import EventScrubber
 from sentry_sdk.serializer import serialize
 from sentry_sdk.sessions import SessionFlusher
 from sentry_sdk.traces import SpanStatus, StreamedSpan
-from sentry_sdk.tracing import trace
+from sentry_sdk.traces import trace as streaming_trace
+from sentry_sdk.tracing import trace as legacy_trace
 from sentry_sdk.tracing_utils import has_span_streaming_enabled
 from sentry_sdk.transport import (
     AsyncHttpTransport,
@@ -533,8 +534,14 @@ class _Client(BaseClient):
         self, functions_to_trace: "Sequence[Dict[str, str]]"
     ) -> None:
         """
-        Instruments the functions given in the list `functions_to_trace` with the `@sentry_sdk.tracing.trace` decorator.
+        Instruments the functions given in the list `functions_to_trace` with a trace decorator.
         """
+        trace = (
+            streaming_trace
+            if has_span_streaming_enabled(self.options)
+            else legacy_trace
+        )
+
         for function in functions_to_trace:
             class_name = None
             function_qualname = function["qualified_name"]
@@ -776,6 +783,7 @@ class _Client(BaseClient):
             event["timestamp"] = datetime.now(timezone.utc)
 
         is_transaction = event.get("type") == "transaction"
+        is_checkin = event.get("type") == "check_in"
 
         if scope is not None:
             spans_before = len(cast(List[Dict[str, object]], event.get("spans", [])))
@@ -830,6 +838,7 @@ class _Client(BaseClient):
 
         if (
             not is_transaction
+            and not is_checkin
             and self.options["attach_stacktrace"]
             and "exception" not in event
             and "stacktrace" not in event

{sentry_sdk-2.69.0 → sentry_sdk-2.69.2}/sentry_sdk/consts.py

@@ -7,6 +7,8 @@ DEFAULT_MAX_VALUE_LENGTH = None
 DEFAULT_MAX_STACK_FRAMES = 100
 DEFAULT_ADD_FULL_STACK = False
 
+_SENTRY_HEADER_NAMES = frozenset(("baggage", "sentry-trace"))
+
 
 # Also needs to be at the top to prevent circular import
 class EndpointType(Enum):
@@ -1335,7 +1337,7 @@ class ClientConstructor:
         profile_lifecycle: 'Literal["manual", "trace"]' = "manual",
         profile_session_sample_rate: "Optional[float]" = None,
         auto_enabling_integrations: bool = True,
-        disabled_integrations: "Optional[Sequence[sentry_sdk.integrations.Integration]]" = None,
+        disabled_integrations: "Optional[Sequence[Union[sentry_sdk.integrations.Integration, type[sentry_sdk.integrations.Integration]]]]" = None,
         auto_session_tracking: bool = True,
         send_client_reports: bool = True,
         _experiments: "Experiments" = {},  # noqa: B006
@@ -1846,4 +1848,4 @@ DEFAULT_OPTIONS = _get_default_options()
 del _get_default_options
 
 
-VERSION = "2.69.0"
+VERSION = "2.69.2"

{sentry_sdk-2.69.0 → sentry_sdk-2.69.2}/sentry_sdk/integrations/aiohttp.py

@@ -4,7 +4,7 @@ from functools import wraps
 
 import sentry_sdk
 from sentry_sdk.api import continue_trace
-from sentry_sdk.consts import OP, SPANDATA, SPANSTATUS
+from sentry_sdk.consts import _SENTRY_HEADER_NAMES, OP, SPANDATA, SPANSTATUS
 from sentry_sdk.data_collection import (
     _apply_data_collection_filtering_to_query_string,
 )
@@ -29,6 +29,7 @@ from sentry_sdk.traces import (
 )
 from sentry_sdk.tracing import (
     BAGGAGE_HEADER_NAME,
+    SENTRY_TRACE_HEADER_NAME,
     SOURCE_FOR_STYLE,
     TransactionSource,
 )
@@ -43,6 +44,8 @@ from sentry_sdk.utils import (
     HAS_REAL_CONTEXTVARS,
     SENSITIVE_DATA_SUBSTITUTE,
     AnnotatedValue,
+    _get_aws_sigv4_signed_headers_from_authorization_header,
+    _get_aws_sigv4_signed_headers_from_url_query_string,
     _register_control_flow_exception,
     capture_internal_exceptions,
     ensure_integration_enabled,
@@ -464,12 +467,50 @@ def create_trace_config() -> "TraceConfig":
             span = legacy_span
 
         if should_propagate_trace(client, str(params.url)):
+            # existing `sentry-trace`: skip so it is not duplicated.
+            headers_to_skip: "set[str]" = set()
+            if SENTRY_TRACE_HEADER_NAME in params.headers:
+                headers_to_skip.add(SENTRY_TRACE_HEADER_NAME)
+
+            with capture_internal_exceptions():
+                authorization = params.headers.get("Authorization")
+                if authorization:
+                    if isinstance(authorization, bytes):
+                        authorization = authorization.decode("latin-1")
+                    # `SignedHeaders` lists fields covered by SigV4.
+                    signed_headers = (
+                        _get_aws_sigv4_signed_headers_from_authorization_header(
+                            authorization
+                        )
+                    )
+                    # skip signed `sentry-trace` and `baggage`.
+                    headers_to_skip.update(
+                        _SENTRY_HEADER_NAMES.intersection(signed_headers)
+                    )
+
+                # presigned URLs list signed names in the query string.
+                query_signed_headers = (
+                    _get_aws_sigv4_signed_headers_from_url_query_string(str(params.url))
+                )
+                headers_to_skip.update(
+                    _SENTRY_HEADER_NAMES.intersection(query_signed_headers)
+                )
+
             for (
                 key,
                 value,
             ) in sentry_sdk.get_current_scope().iter_trace_propagation_headers(
                 span=span
             ):
+                # skip signed headers and an existing `sentry-trace`.
+                if key.lower() in headers_to_skip:
+                    logger.debug(
+                        "[Tracing] Not adding `{key}` header to outgoing request "
+                        "to {url}: it already exists or is covered by the AWS "
+                        "SigV4 signature.".format(key=key, url=params.url)
+                    )
+                    continue
+
                 logger.debug(
                     "[Tracing] Adding `{key}` header {value} to outgoing request to {url}.".format(
                         key=key, value=value, url=params.url

{sentry_sdk-2.69.0 → sentry_sdk-2.69.2}/sentry_sdk/integrations/aws_lambda.py

@@ -45,6 +45,27 @@ TIMEOUT_WARNING_BUFFER = 1500  # Buffer time required to send timeout warning to
 MILLIS_TO_SECONDS = 1000.0
 
 
+def _get_user_from_event(aws_event: "dict[str, Any]") -> "dict[str, Any]":
+    if not isinstance(aws_event, dict):
+        return {}
+
+    identity = aws_event.get("requestContext", {}).get("identity")
+    if identity is None:
+        return {}
+
+    user_info: "dict[str, Any]" = {}
+
+    user_arn = identity.get("userArn")
+    if user_arn is not None:
+        user_info["id"] = user_arn
+
+    ip = identity.get("sourceIp")
+    if ip is not None:
+        user_info["ip_address"] = ip
+
+    return user_info
+
+
 def _wrap_init_error(init_error: "F") -> "F":
     @ensure_integration_enabled(AwsLambdaIntegration, init_error)
     def sentry_init_error(*args: "Any", **kwargs: "Any") -> "Any":
@@ -181,6 +202,17 @@ def _wrap_handler(handler: "F") -> "F":
                     elif should_send_default_pii():
                         additional_attributes["url.query"] = urlencode(qs)
 
+            if not scope._user:
+                if has_data_collection_enabled(client.options):
+                    if client.options["data_collection"]["user_info"]:
+                        user_info = _get_user_from_event(request_data)
+                        if user_info:
+                            scope.set_user(user_info)
+                elif should_send_default_pii():
+                    user_info = _get_user_from_event(request_data)
+                    if user_info:
+                        scope.set_user(user_info)
+
             sampling_context = {
                 "aws_event": aws_event,
                 "aws_context": aws_context,
@@ -440,38 +472,22 @@ def _make_request_event_processor(
         client_options = sentry_sdk.get_client().options
         if has_data_collection_enabled(client_options):
             if client_options["data_collection"]["user_info"]:
-                user_info = sentry_event.setdefault("user", {})
-
-                identity = aws_event.get("requestContext", {}).get("identity")
-                if identity is None:
-                    identity = {}
-
-                id = identity.get("userArn")
-                if id is not None:
-                    user_info.setdefault("id", id)
-
-                ip = identity.get("sourceIp")
-                if ip is not None:
-                    user_info.setdefault("ip_address", ip)
+                extracted_user = _get_user_from_event(aws_event)
+                if extracted_user:
+                    user_info = sentry_event.setdefault("user", {})
+                    for key, value in extracted_user.items():
+                        user_info.setdefault(key, value)
 
             if "incoming_request" in client_options["data_collection"]["http_bodies"]:
                 if "body" in aws_event:
                     request["data"] = aws_event.get("body", "")
 
         elif should_send_default_pii():
-            user_info = sentry_event.setdefault("user", {})
-
-            identity = aws_event.get("requestContext", {}).get("identity")
-            if identity is None:
-                identity = {}
-
-            id = identity.get("userArn")
-            if id is not None:
-                user_info.setdefault("id", id)
-
-            ip = identity.get("sourceIp")
-            if ip is not None:
-                user_info.setdefault("ip_address", ip)
+            extracted_user = _get_user_from_event(aws_event)
+            if extracted_user:
+                user_info = sentry_event.setdefault("user", {})
+                for key, value in extracted_user.items():
+                    user_info.setdefault(key, value)
 
             if "body" in aws_event:
                 request["data"] = aws_event.get("body", "")

{sentry_sdk-2.69.0 → sentry_sdk-2.69.2}/sentry_sdk/integrations/bottle.py

@@ -75,6 +75,19 @@ class BottleIntegration(Integration):
         version = parse_version(BOTTLE_VERSION)
         _check_minimum_version(BottleIntegration, version)
 
+        # Bottle's Route.__repr__ might lead to a never-terminating while True
+        # loop when attach_stacktrace=True.
+        def _sentry_route_repr(self: "Route") -> str:
+            cb = self.callback
+            return "<%s %s -> %s:%s>" % (
+                self.method,
+                self.rule,
+                getattr(cb, "__module__", "?"),
+                getattr(cb, "__name__", "?"),
+            )
+
+        Route.__sentry_repr__ = _sentry_route_repr
+
         old_app = Bottle.__call__
 
         @ensure_integration_enabled(BottleIntegration, old_app)

{sentry_sdk-2.69.0 → sentry_sdk-2.69.2}/sentry_sdk/integrations/clickhouse_driver.py

@@ -161,7 +161,7 @@ def _wrap_end(f: "Callable[P, T]") -> "Callable[P, T]":
             sentry_sdk.get_isolation_scope().add_breadcrumb(
                 message=query,
                 category="query",
-                data={"db.result": res, **breadcrumb_data},
+                data=breadcrumb_data,
             )
 
         span = getattr(instance.connection, "_sentry_span", None)

{sentry_sdk-2.69.0 → sentry_sdk-2.69.2}/sentry_sdk/integrations/django/__init__.py

@@ -451,7 +451,10 @@ def _patch_django_asgi_handler() -> None:
 
 
 def _set_transaction_name_and_source(
-    scope: "sentry_sdk.Scope", transaction_style: str, request: "WSGIRequest"
+    scope: "sentry_sdk.Scope",
+    transaction_style: str,
+    request: "WSGIRequest",
+    route_path: "Optional[str]",
 ) -> None:
     try:
         transaction_name = None
@@ -459,13 +462,8 @@ def _set_transaction_name_and_source(
             fn = resolve(request.path).func
             transaction_name = transaction_from_function(getattr(fn, "view_class", fn))
 
-        elif transaction_style == "url":
-            if hasattr(request, "urlconf"):
-                transaction_name = LEGACY_RESOLVER.resolve(
-                    request.path_info, urlconf=request.urlconf
-                )
-            else:
-                transaction_name = LEGACY_RESOLVER.resolve(request.path_info)
+        elif transaction_style == "url" and route_path is not None:
+            transaction_name = route_path
 
         if transaction_name is None:
             transaction_name = request.path_info
@@ -477,6 +475,11 @@ def _set_transaction_name_and_source(
             transaction_name,
             source=source,
         )
+
+        if transaction_style == "url" and route_path is not None:
+            server_span = scope._server_segment_span
+            if server_span is not None:
+                server_span.set_attribute(SPANDATA.HTTP_ROUTE, route_path)
     except Resolver404:
         urlconf = import_module(settings.ROOT_URLCONF)
         # This exception only gets thrown when transaction_style is `function_name`
@@ -501,8 +504,29 @@ def _before_get_response(request: "WSGIRequest") -> None:
     _patch_drf()
 
     scope = sentry_sdk.get_current_scope()
+
+    route_path = None
+    if hasattr(request, "urlconf"):
+        try:
+            route_path = LEGACY_RESOLVER.resolve(
+                request.path_info, urlconf=request.urlconf
+            )
+        except Exception:
+            pass
+    else:
+        try:
+            route_path = LEGACY_RESOLVER.resolve(request.path_info)
+        except Exception:
+            pass
+
+    server_span = sentry_sdk.get_current_scope()._server_segment_span
+    if server_span is not None and route_path is not None:
+        server_span.set_attribute(SPANDATA.HTTP_ROUTE, route_path)
+
     # Rely on WSGI middleware to start a trace
-    _set_transaction_name_and_source(scope, integration.transaction_style, request)
+    _set_transaction_name_and_source(
+        scope, integration.transaction_style, request, route_path=route_path
+    )
 
     scope.add_event_processor(
         _make_wsgi_request_event_processor(weakref.ref(request), integration)
@@ -520,7 +544,27 @@ def _attempt_resolve_again(
     if not hasattr(request, "urlconf"):
         return
 
-    _set_transaction_name_and_source(scope, transaction_style, request)
+    route_path = None
+    if hasattr(request, "urlconf"):
+        try:
+            route_path = LEGACY_RESOLVER.resolve(
+                request.path_info, urlconf=request.urlconf
+            )
+        except Exception:
+            pass
+    else:
+        try:
+            route_path = LEGACY_RESOLVER.resolve(request.path_info)
+        except Exception:
+            pass
+
+    server_span = sentry_sdk.get_current_scope()._server_segment_span
+    if server_span is not None and route_path is not None:
+        server_span.set_attribute(SPANDATA.HTTP_ROUTE, route_path)
+
+    _set_transaction_name_and_source(
+        scope, transaction_style, request, route_path=route_path
+    )
 
 
 def _get_user_from_request_and_set_on_scope(request: "WSGIRequest") -> None:

{sentry_sdk-2.69.0 → sentry_sdk-2.69.2}/sentry_sdk/integrations/google_genai/utils.py

@@ -608,7 +608,7 @@ def extract_tool_calls(
 
     # Extract from candidates, sometimes tool calls are nested under the content.parts object
     candidates = getattr(response, "candidates", [])
-    if response is not None:
+    if candidates and response is not None:
         for candidate in candidates:
             if not hasattr(candidate, "content") or not getattr(
                 candidate.content, "parts", []

{sentry_sdk-2.69.0 → sentry_sdk-2.69.2}/sentry_sdk/integrations/pydantic_ai/patches/tools.py

@@ -1,4 +1,5 @@
 import sys
+from contextlib import nullcontext
 from functools import wraps
 from typing import TYPE_CHECKING
 
@@ -60,11 +61,15 @@ def _patch_execute_tool_call() -> None:
             # Create execute_tool span
             # Nesting is handled by isolation_scope() to ensure proper parent-child relationships
             with sentry_sdk.isolation_scope():
-                with execute_tool_span(
-                    name,
-                    args_dict,
-                    agent,
-                    tool_definition=selected_tool_definition,
+                with (
+                    execute_tool_span(
+                        name,
+                        args_dict,
+                        agent,
+                        tool_definition=selected_tool_definition,
+                    )
+                    if validated.args_valid
+                    else nullcontext()
                 ) as span:
                     try:
                         result = await original_execute_tool_call(
@@ -73,7 +78,8 @@ def _patch_execute_tool_call() -> None:
                             *args,
                             **kwargs,
                         )
-                        update_execute_tool_span(span, result)
+                        if span is not None:
+                            update_execute_tool_span(span, result)
                         return result
                     except ToolRetryError as exc:
                         exc_info = sys.exc_info()

{sentry_sdk-2.69.0 → sentry_sdk-2.69.2}/sentry_sdk/integrations/stdlib.py

@@ -6,11 +6,11 @@ from http.client import HTTPConnection, HTTPResponse
 from typing import TYPE_CHECKING
 
 import sentry_sdk
-from sentry_sdk.consts import OP, SPANDATA
+from sentry_sdk.consts import _SENTRY_HEADER_NAMES, OP, SPANDATA
 from sentry_sdk.integrations import Integration
 from sentry_sdk.scope import add_global_event_processor
 from sentry_sdk.traces import StreamedSpan
-from sentry_sdk.tracing import BAGGAGE_HEADER_NAME, SENTRY_TRACE_HEADER_NAME, Span
+from sentry_sdk.tracing import SENTRY_TRACE_HEADER_NAME, Span
 from sentry_sdk.tracing_utils import (
     EnvironHeaders,
     add_http_breadcrumb,
@@ -42,9 +42,6 @@ _RUNTIME_CONTEXT: "dict[str, object]" = {
     "version": "%s.%s.%s" % (sys.version_info[:3]),
     "build": sys.version,
 }
-
-_SENTRY_HEADER_NAMES = frozenset((BAGGAGE_HEADER_NAME, SENTRY_TRACE_HEADER_NAME))
-
 try:
     from botocore.awsrequest import AWSHTTPConnection, AWSHTTPSConnection
 except ImportError:

{sentry_sdk-2.69.0 → sentry_sdk-2.69.2}/sentry_sdk/serializer.py

@@ -43,8 +43,8 @@ MAX_EVENT_BYTES = 10**6
 
 # Maximum depth and breadth of databags. Excess data will be trimmed. If
 # max_request_body_size is "always", request bodies won't be trimmed.
-MAX_DATABAG_DEPTH = 5
-MAX_DATABAG_BREADTH = 10
+MAX_DATABAG_DEPTH: int = 5
+MAX_DATABAG_BREADTH: int = 10
 CYCLE_MARKER = "<cyclic>"
 
 

{sentry_sdk-2.69.0 → sentry_sdk-2.69.2}/sentry_sdk/traces.py

@@ -1,10 +1,21 @@
 """
-EXPERIMENTAL. Do not use in production.
+The API in this file is only meant to be used in span streaming mode. It should
+not be mixed with the legacy tracing API (sentry_sdk.start_transaction,
+sentry_sdk.start_span, etc.).
 
-The API in this file is only meant to be used in span streaming mode.
+You can enable span streaming mode via:
 
-You can enable span streaming mode via
-sentry_sdk.init(trace_lifecycle="stream").
+```
+import sentry_sdk
+
+sentry_sdk.init(
+    trace_lifecycle="stream",
+)
+```
+
+See
+https://docs.sentry.io/platforms/python/tracing/streamed-spans/migration-guide/
+for how to migrate to span streaming.
 """
 
 import sys
@@ -110,10 +121,7 @@ def start_span(
     active: bool = True,
 ) -> "StreamedSpan":
     """
-    Start a span.
-
-    EXPERIMENTAL. Use sentry_sdk.start_transaction() and sentry_sdk.start_span()
-    instead.
+    Start a span in streaming mode.
 
     The span's parent, unless provided explicitly via the `parent_span` argument,
     will be the current active span, if any. If there is none, this span will
@@ -185,9 +193,7 @@ def start_span(
 
 def continue_trace(incoming: "dict[str, Any]") -> None:
     """
-    Continue a trace from headers or environment variables.
-
-    EXPERIMENTAL. Use sentry_sdk.continue_trace() instead.
+    Continue a trace from headers or environment variables in streaming mode.
 
     This function sets the propagation context on the scope. Any span started
     in the updated scope will belong under the trace extracted from the
@@ -211,9 +217,7 @@ def continue_trace(incoming: "dict[str, Any]") -> None:
 
 def new_trace() -> None:
     """
-    Resets the propagation context, forcing a new trace.
-
-    EXPERIMENTAL.
+    Resets the propagation context, forcing a new trace, in streaming mode.
 
     This function sets the propagation context on the scope. Any span started
     in the updated scope will start its own trace.
@@ -811,9 +815,7 @@ def trace(
     active: bool = True,
 ) -> "Union[Callable[P, R], Callable[[Callable[P, R]], Callable[P, R]]]":
     """
-    Decorator to start a span around a function call.
-
-    EXPERIMENTAL. Use @sentry_sdk.trace instead.
+    Decorator to start a span around a function call in streaming mode.
 
     This decorator automatically creates a new span when the decorated function
     is called, and finishes the span when the function returns or raises an exception.

{sentry_sdk-2.69.0 → sentry_sdk-2.69.2}/sentry_sdk/utils.py

@@ -1,4 +1,3 @@
-import base64
 import copy
 import json
 import linecache
@@ -85,8 +84,6 @@ logger = logging.getLogger("sentry_sdk.errors")
 
 _installed_modules = None
 
-BASE64_ALPHABET = re.compile(r"^[a-zA-Z0-9/+=]*$")
-
 FALSY_ENV_VALUES = frozenset(("false", "f", "n", "no", "off", "0"))
 TRUTHY_ENV_VALUES = frozenset(("true", "t", "y", "yes", "on", "1"))
 _AWS_SIGV4_SIGNING_ALGORITHMS = frozenset(
@@ -1620,43 +1617,6 @@ class TimeoutThread(threading.Thread):
         )
 
 
-def to_base64(original: str) -> "Optional[str]":
-    """
-    Convert a string to base64, via UTF-8. Returns None on invalid input.
-    """
-    base64_string = None
-
-    try:
-        utf8_bytes = original.encode("UTF-8")
-        base64_bytes = base64.b64encode(utf8_bytes)
-        base64_string = base64_bytes.decode("UTF-8")
-    except Exception as err:
-        logger.warning("Unable to encode {orig} to base64:".format(orig=original), err)
-
-    return base64_string
-
-
-def from_base64(base64_string: str) -> "Optional[str]":
-    """
-    Convert a string from base64, via UTF-8. Returns None on invalid input.
-    """
-    utf8_string = None
-
-    try:
-        only_valid_chars = BASE64_ALPHABET.match(base64_string)
-        assert only_valid_chars
-
-        base64_bytes = base64_string.encode("UTF-8")
-        utf8_bytes = base64.b64decode(base64_bytes)
-        utf8_string = utf8_bytes.decode("UTF-8")
-    except Exception as err:
-        logger.warning(
-            "Unable to decode {b64} from base64:".format(b64=base64_string), err
-        )
-
-    return utf8_string
-
-
 Components = namedtuple("Components", ["scheme", "netloc", "path", "query", "fragment"])
 
 

{sentry_sdk-2.69.0 → sentry_sdk-2.69.2/sentry_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry-sdk
-Version: 2.69.0
+Version: 2.69.2
 Summary: Python client for Sentry (https://sentry.io)
 Home-page: https://github.com/getsentry/sentry-python
 Author: Sentry Team and Contributors

{sentry_sdk-2.69.0 → sentry_sdk-2.69.2}/sentry_sdk.egg-info/SOURCES.txt

@@ -297,6 +297,8 @@ tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/BasicOkSpanStre
 tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/BasicOkSpanStreaming/index.py
 tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/BasicOkSpanStreamingDataCollection/.gitignore
 tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/BasicOkSpanStreamingDataCollection/index.py
+tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/BasicOkSpanStreamingDataCollectionUserInfoOff/index.py
+tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/BasicOkSpanStreamingDataCollectionUserInfoOn/index.py
 tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/BasicOkSpanStreamingPii/.gitignore
 tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/BasicOkSpanStreamingPii/index.py
 tests/integrations/aws_lambda/lambda_functions_with_embedded_sdk/RaiseErrorPerformanceDisabled/.gitignore

{sentry_sdk-2.69.0 → sentry_sdk-2.69.2}/setup.py

@@ -22,7 +22,7 @@ def get_file_text(file_name):
 
 setup(
     name="sentry-sdk",
-    version="2.69.0",
+    version="2.69.2",
     author="Sentry Team and Contributors",
     author_email="hello@sentry.io",
     url="https://github.com/getsentry/sentry-python",