Merge branch 'potel-base' into antonpirker/potel/back-pressure

Author: antonpirker

CONTRIBUTING-aws-lambda.md

@@ -172,3 +172,24 @@ sentry-sdk==2.4.0
 ```
 
 A major release `N` implies the previous release `N-1` will no longer receive updates. We generally do not backport bugfixes to older versions unless they are security relevant. However, feel free to ask for backports of specific commits on the bugtracker.
+
+
+## Contributing to Sentry AWS Lambda Layer
+
+### Development environment
+
+You need to have an AWS account and AWS CLI installed and setup.
+
+We put together two helper functions that can help you with development:
+
+- `./scripts/aws-deploy-local-layer.sh`
+
+  This script [scripts/aws-deploy-local-layer.sh](scripts/aws-deploy-local-layer.sh) will take the code you have checked out locally, create a Lambda layer out of it and deploy it to the `eu-central-1` region of your configured AWS account using `aws` CLI.
+
+  The Lambda layer will have the name `SentryPythonServerlessSDK-local-dev`
+
+- `./scripts/aws-attach-layer-to-lambda-function.sh`
+
+  You can use this script [scripts/aws-attach-layer-to-lambda-function.sh](scripts/aws-attach-layer-to-lambda-function.sh) to attach the Lambda layer you just deployed (using the first script) onto one of your existing Lambda functions. You will have to give the name of the Lambda function to attach onto as an argument. (See the script for details.)
+
+With these two helper scripts it should be easy to rapidly iterate your development on the Lambda layer.

CONTRIBUTING.md

@@ -5,13 +5,11 @@ VENV_PATH = .venv
 help:
 	@echo "Thanks for your interest in the Sentry Python SDK!"
 	@echo
-	@echo "make lint: Run linters"
-	@echo "make test: Run basic tests (not testing most integrations)"
-	@echo "make test-all: Run ALL tests (slow, closest to CI)"
-	@echo "make format: Run code formatters (destructive)"
+	@echo "make apidocs: Build the API documentation"
 	@echo "make aws-lambda-layer: Build AWS Lambda layer directory for serverless integration"
 	@echo
 	@echo "Also make sure to read ./CONTRIBUTING.md"
+	@echo
 	@false
 
 .venv:
@@ -24,42 +22,13 @@ dist: .venv
 	$(VENV_PATH)/bin/python setup.py sdist bdist_wheel
 .PHONY: dist
 
-format: .venv
-	$(VENV_PATH)/bin/tox -e linters --notest
-	.tox/linters/bin/black .
-.PHONY: format
-
-test: .venv
-	@$(VENV_PATH)/bin/tox -e py3.12
-.PHONY: test
-
-test-all: .venv
-	@TOXPATH=$(VENV_PATH)/bin/tox sh ./scripts/runtox.sh
-.PHONY: test-all
-
-check: lint test
-.PHONY: check
-
-lint: .venv
-	@set -e && $(VENV_PATH)/bin/tox -e linters || ( \
-		echo "================================"; \
-		echo "Bad formatting? Run: make format"; \
-		echo "================================"; \
-		false)
-.PHONY: lint
-
 apidocs: .venv
 	@$(VENV_PATH)/bin/pip install --editable .
 	@$(VENV_PATH)/bin/pip install -U -r ./requirements-docs.txt
 	rm -rf docs/_build
 	@$(VENV_PATH)/bin/sphinx-build -vv -W -b html docs/ docs/_build
 .PHONY: apidocs
 
-apidocs-hotfix: apidocs
-	@$(VENV_PATH)/bin/pip install ghp-import
-	@$(VENV_PATH)/bin/ghp-import -pf docs/_build
-.PHONY: apidocs-hotfix
-
 aws-lambda-layer: dist
 	$(VENV_PATH)/bin/pip install -r requirements-aws-lambda-layer.txt
 	$(VENV_PATH)/bin/python -m scripts.build_aws_lambda_layer

Makefile

@@ -10,5 +10,7 @@ executing
 asttokens
 responses
 pysocks
+socksio
+httpcore[http2]
 setuptools
-freezegun
+freezegun

requirements-testing.txt

@@ -22,7 +22,7 @@
 )
 from sentry_sdk.serializer import serialize
 from sentry_sdk.tracing import trace
-from sentry_sdk.transport import HttpTransport, make_transport
+from sentry_sdk.transport import BaseHttpTransport, make_transport
 from sentry_sdk.consts import (
     DEFAULT_MAX_VALUE_LENGTH,
     DEFAULT_OPTIONS,
@@ -58,6 +58,7 @@
     from sentry_sdk.integrations import Integration
     from sentry_sdk.scope import Scope
     from sentry_sdk.session import Session
+    from sentry_sdk.spotlight import SpotlightClient
     from sentry_sdk.transport import Transport
 
     I = TypeVar("I", bound=Integration)  # noqa: E741
@@ -139,6 +140,8 @@ class BaseClient:
     The basic definition of a client that is used for sending data to Sentry.
     """
 
+    spotlight = None  # type: Optional[SpotlightClient]
+
     def __init__(self, options=None):
         # type: (Optional[Dict[str, Any]]) -> None
         self.options = (
@@ -337,7 +340,6 @@ def _capture_envelope(envelope):
                 disabled_integrations=self.options["disabled_integrations"],
             )
 
-            self.spotlight = None
             spotlight_config = self.options.get("spotlight")
             if spotlight_config is None and "SENTRY_SPOTLIGHT" in os.environ:
                 spotlight_env_value = os.environ["SENTRY_SPOTLIGHT"]
@@ -378,7 +380,7 @@ def _capture_envelope(envelope):
         if (
             self.monitor
             or has_profiling_enabled(self.options)
-            or isinstance(self.transport, HttpTransport)
+            or isinstance(self.transport, BaseHttpTransport)
         ):
             # If we have anything on that could spawn a background thread, we
             # need to check if it's safe to use them.

sentry_sdk/client.py

@@ -57,6 +57,7 @@ class EndpointType(Enum):
             "otel_powered_performance": Optional[bool],
             "transport_zlib_compression_level": Optional[int],
             "transport_num_pools": Optional[int],
+            "transport_http2": Optional[bool],
         },
         total=False,
     )

sentry_sdk/consts.py

@@ -6,6 +6,7 @@
 
 import asyncio
 import inspect
+from contextlib import nullcontext
 from copy import deepcopy
 from functools import partial
 
@@ -190,9 +191,10 @@ async def _run_app(self, scope, receive, send, asgi_version):
                     )
 
                     method = scope.get("method", "").upper()
-                    if method in self.http_methods_to_capture:
-                        with sentry_sdk.continue_trace(_get_headers(scope)):
-                            with sentry_sdk.start_transaction(
+                    should_trace = method in self.http_methods_to_capture
+                    with sentry_sdk.continue_trace(_get_headers(scope)):
+                        with (
+                            sentry_sdk.start_transaction(
                                 op=(
                                     OP.WEBSOCKET_SERVER
                                     if ty == "websocket"
@@ -202,37 +204,42 @@ async def _run_app(self, scope, receive, send, asgi_version):
                                 source=transaction_source,
                                 origin=self.span_origin,
                                 custom_sampling_context={"asgi_scope": scope},
-                            ) as transaction:
+                            )
+                            if should_trace
+                            else nullcontext()
+                        ) as transaction:
+                            if transaction is not None:
                                 logger.debug(
                                     "[ASGI] Started transaction: %s", transaction
                                 )
                                 transaction.set_tag("asgi.type", ty)
-                                try:
-
-                                    async def _sentry_wrapped_send(event):
-                                        # type: (Dict[str, Any]) -> Any
-                                        is_http_response = (
-                                            event.get("type") == "http.response.start"
-                                            and "status" in event
-                                        )
-                                        if is_http_response:
-                                            transaction.set_http_status(event["status"])
-
-                                        return await send(event)
-
-                                    if asgi_version == 2:
-                                        return await self.app(scope)(
-                                            receive, _sentry_wrapped_send
-                                        )
-                                    else:
-                                        return await self.app(
-                                            scope, receive, _sentry_wrapped_send
-                                        )
-                                except Exception as exc:
-                                    _capture_exception(
-                                        exc, mechanism_type=self.mechanism_type
+                            try:
+
+                                async def _sentry_wrapped_send(event):
+                                    # type: (Dict[str, Any]) -> Any
+                                    is_http_response = (
+                                        event.get("type") == "http.response.start"
+                                        and transaction is not None
+                                        and "status" in event
                                     )
-                                    raise exc from None
+                                    if is_http_response:
+                                        transaction.set_http_status(event["status"])
+
+                                    return await send(event)
+
+                                if asgi_version == 2:
+                                    return await self.app(scope)(
+                                        receive, _sentry_wrapped_send
+                                    )
+                                else:
+                                    return await self.app(
+                                        scope, receive, _sentry_wrapped_send
+                                    )
+                            except Exception as exc:
+                                _capture_exception(
+                                    exc, mechanism_type=self.mechanism_type
+                                )
+                                raise exc from None
         finally:
             _asgi_middleware_applied.set(False)
 

sentry_sdk/integrations/asgi.py

@@ -30,7 +30,6 @@
         Bottle,
         Route,
         request as bottle_request,
-        HTTPResponse,
         __version__ as BOTTLE_VERSION,
     )
 except ImportError:
@@ -114,8 +113,6 @@ def wrapped_callback(*args, **kwargs):
 
                 try:
                     res = prepared_callback(*args, **kwargs)
-                except HTTPResponse:
-                    raise
                 except Exception as exception:
                     event, hint = event_from_exception(
                         exception,

sentry_sdk/integrations/bottle.py

@@ -90,13 +90,15 @@ def patch_django_asgi_handler_impl(cls):
 
     async def sentry_patched_asgi_handler(self, scope, receive, send):
         # type: (Any, Any, Any, Any) -> Any
-        if sentry_sdk.get_client().get_integration(DjangoIntegration) is None:
+        integration = sentry_sdk.get_client().get_integration(DjangoIntegration)
+        if integration is None:
             return await old_app(self, scope, receive, send)
 
         middleware = SentryAsgiMiddleware(
             old_app.__get__(self, cls),
             unsafe_context_data=True,
             span_origin=DjangoIntegration.origin,
+            http_methods_to_capture=integration.http_methods_to_capture,
         )._run_asgi3
 
         return await middleware(scope, receive, send)
@@ -142,13 +144,15 @@ def patch_channels_asgi_handler_impl(cls):
 
         async def sentry_patched_asgi_handler(self, receive, send):
             # type: (Any, Any, Any) -> Any
-            if sentry_sdk.get_client().get_integration(DjangoIntegration) is None:
+            integration = sentry_sdk.get_client().get_integration(DjangoIntegration)
+            if integration is None:
                 return await old_app(self, receive, send)
 
             middleware = SentryAsgiMiddleware(
                 lambda _scope: old_app.__get__(self, cls),
                 unsafe_context_data=True,
                 span_origin=DjangoIntegration.origin,
+                http_methods_to_capture=integration.http_methods_to_capture,
             )
 
             return await middleware(self.scope)(receive, send)

sentry_sdk/integrations/django/asgi.py

@@ -1,4 +1,5 @@
 from opentelemetry.context import create_key
+from sentry_sdk.tracing_utils import Baggage
 
 
 # propagation keys
@@ -11,7 +12,8 @@
 SENTRY_USE_CURRENT_SCOPE_KEY = create_key("sentry_use_current_scope")
 SENTRY_USE_ISOLATION_SCOPE_KEY = create_key("sentry_use_isolation_scope")
 
-SENTRY_TRACE_STATE_DROPPED = "sentry_dropped"
+TRACESTATE_SAMPLED_KEY = Baggage.SENTRY_PREFIX + "sampled"
+TRACESTATE_SAMPLE_RATE_KEY = Baggage.SENTRY_PREFIX + "sample_rate"
 
 OTEL_SENTRY_CONTEXT = "otel"
 SPAN_ORIGIN = "auto.otel"