Merge branch 'potel-base' of github.com:getsentry/sentry-python into potel-base

Author: antonpirker

MIGRATION_GUIDE.md

@@ -105,6 +105,19 @@ Looking to upgrade from Sentry SDK 2.x to 3.x? Here's a comprehensive list of wh
   | `aws_event["headers"]["Host"]`              | `server.address`        |
   | `aws_context["function_name"]`              | `faas.name`             |
 
+- If you're using the GCP integration, the `sampling_context` argument of `traces_sampler` doesn't contain the `gcp_env` and `gcp_event` keys anymore. Instead, the following, if available, is accessible:
+
+  | Old sampling context key          | New sampling context key   |
+  | --------------------------------- | -------------------------- |
+  | `gcp_env["function_name"]`        | `faas.name`                |
+  | `gcp_env["function_region"]`      | `faas.region`              |
+  | `gcp_env["function_project"]`     | `gcp.function.project`     |
+  | `gcp_env["function_identity"]`    | `gcp.function.identity`    |
+  | `gcp_env["function_entry_point"]` | `gcp.function.entry_point` |
+  | `gcp_event.method`                | `http.request.method`      |
+  | `gcp_event.query_string`          | `url.query`                |
+
+
 ### Removed
 
 - Spans no longer have a `description`. Use `name` instead.

sentry_sdk/integrations/aws_lambda.py

@@ -468,7 +468,9 @@ def _event_from_error_json(error_json):
 
 
 def _prepopulate_attributes(aws_event, aws_context):
-    attributes = {}
+    attributes = {
+        "cloud.provider": "aws",
+    }
 
     for prop, attr in EVENT_TO_ATTRIBUTES.items():
         if aws_event.get(prop) is not None:

sentry_sdk/integrations/gcp.py

@@ -84,22 +84,12 @@ def sentry_func(functionhandler, gcp_event, *args, **kwargs):
                 headers = gcp_event.headers
 
             with sentry_sdk.continue_trace(headers):
-                sampling_context = {
-                    "gcp_env": {
-                        "function_name": environ.get("FUNCTION_NAME"),
-                        "function_entry_point": environ.get("ENTRY_POINT"),
-                        "function_identity": environ.get("FUNCTION_IDENTITY"),
-                        "function_region": environ.get("FUNCTION_REGION"),
-                        "function_project": environ.get("GCP_PROJECT"),
-                    },
-                    "gcp_event": gcp_event,
-                }
                 with sentry_sdk.start_transaction(
                     op=OP.FUNCTION_GCP,
                     name=environ.get("FUNCTION_NAME", ""),
                     source=TRANSACTION_SOURCE_COMPONENT,
                     origin=GcpIntegration.origin,
-                    custom_sampling_context=sampling_context,
+                    attributes=_prepopulate_attributes(gcp_event),
                 ):
                     try:
                         return func(functionhandler, gcp_event, *args, **kwargs)
@@ -229,3 +219,33 @@ def _get_google_cloud_logs_url(final_time):
     )
 
     return url
+
+
+ENV_TO_ATTRIBUTE = {
+    "FUNCTION_NAME": "faas.name",
+    "ENTRY_POINT": "gcp.function.entry_point",
+    "FUNCTION_IDENTITY": "gcp.function.identity",
+    "FUNCTION_REGION": "faas.region",
+    "GCP_PROJECT": "gcp.function.project",
+}
+
+EVENT_TO_ATTRIBUTE = {
+    "method": "http.request.method",
+    "query_string": "url.query",
+}
+
+
+def _prepopulate_attributes(gcp_event):
+    attributes = {
+        "cloud.provider": "gcp",
+    }
+
+    for key, attr in ENV_TO_ATTRIBUTE.items():
+        if environ.get(key):
+            attributes[attr] = environ[key]
+
+    for key, attr in EVENT_TO_ATTRIBUTE.items():
+        if getattr(gcp_event, key, None):
+            attributes[attr] = getattr(gcp_event, key)
+
+    return attributes

sentry_sdk/integrations/opentelemetry/utils.py

@@ -161,36 +161,43 @@ def span_data_for_http_method(span):
     # type: (ReadableSpan) -> OtelExtractedSpanData
     span_attributes = span.attributes or {}
 
-    op = "http"
+    op = span_attributes.get(SentrySpanAttribute.OP)
+    if op is None:
+        op = "http"
 
-    if span.kind == SpanKind.SERVER:
-        op += ".server"
-    elif span.kind == SpanKind.CLIENT:
-        op += ".client"
+        if span.kind == SpanKind.SERVER:
+            op += ".server"
+        elif span.kind == SpanKind.CLIENT:
+            op += ".client"
 
     http_method = span_attributes.get(SpanAttributes.HTTP_METHOD)
     route = span_attributes.get(SpanAttributes.HTTP_ROUTE)
     target = span_attributes.get(SpanAttributes.HTTP_TARGET)
     peer_name = span_attributes.get(SpanAttributes.NET_PEER_NAME)
 
-    description = f"{http_method}"
-
-    if route:
-        description = f"{http_method} {route}"
-    elif target:
-        description = f"{http_method} {target}"
-    elif peer_name:
-        description = f"{http_method} {peer_name}"
-    else:
-        url = span_attributes.get(SpanAttributes.HTTP_URL)
-        url = cast("Optional[str]", url)
-
-        if url:
-            parsed_url = urlparse(url)
-            url = "{}://{}{}".format(
-                parsed_url.scheme, parsed_url.netloc, parsed_url.path
-            )
-            description = f"{http_method} {url}"
+    # TODO-neel-potel remove description completely
+    description = span_attributes.get(
+        SentrySpanAttribute.DESCRIPTION
+    ) or span_attributes.get(SentrySpanAttribute.NAME)
+    if description is None:
+        description = f"{http_method}"
+
+        if route:
+            description = f"{http_method} {route}"
+        elif target:
+            description = f"{http_method} {target}"
+        elif peer_name:
+            description = f"{http_method} {peer_name}"
+        else:
+            url = span_attributes.get(SpanAttributes.HTTP_URL)
+            url = cast("Optional[str]", url)
+
+            if url:
+                parsed_url = urlparse(url)
+                url = "{}://{}{}".format(
+                    parsed_url.scheme, parsed_url.netloc, parsed_url.path
+                )
+                description = f"{http_method} {url}"
 
     status, http_status = extract_span_status(span)
 

sentry_sdk/integrations/rust_tracing.py

@@ -37,11 +37,9 @@
 import sentry_sdk
 from sentry_sdk.integrations import Integration
 from sentry_sdk.scope import should_send_default_pii
-from sentry_sdk.tracing import Span as SentrySpan
+from sentry_sdk.tracing import POTelSpan as SentrySpan
 from sentry_sdk.utils import SENSITIVE_DATA_SUBSTITUTE
 
-TraceState = Optional[Tuple[Optional[SentrySpan], SentrySpan]]
-
 
 class RustTracingLevel(Enum):
     Trace: str = "TRACE"
@@ -171,7 +169,7 @@ def _include_tracing_fields(self) -> bool:
             else self.include_tracing_fields
         )
 
-    def on_event(self, event: str, _span_state: TraceState) -> None:
+    def on_event(self, event: str, _span_state: Optional[SentrySpan]) -> None:
         deserialized_event = json.loads(event)
         metadata = deserialized_event.get("metadata", {})
 
@@ -185,7 +183,7 @@ def on_event(self, event: str, _span_state: TraceState) -> None:
         elif event_type == EventTypeMapping.Event:
             process_event(deserialized_event)
 
-    def on_new_span(self, attrs: str, span_id: str) -> TraceState:
+    def on_new_span(self, attrs: str, span_id: str) -> Optional[SentrySpan]:
         attrs = json.loads(attrs)
         metadata = attrs.get("metadata", {})
 
@@ -205,48 +203,35 @@ def on_new_span(self, attrs: str, span_id: str) -> TraceState:
         else:
             sentry_span_name = "<unknown>"
 
-        kwargs = {
-            "op": "function",
-            "name": sentry_span_name,
-            "origin": self.origin,
-        }
-
-        scope = sentry_sdk.get_current_scope()
-        parent_sentry_span = scope.span
-        if parent_sentry_span:
-            sentry_span = parent_sentry_span.start_child(**kwargs)
-        else:
-            sentry_span = scope.start_span(**kwargs)
+        span = sentry_sdk.start_span(
+            op="function",
+            name=sentry_span_name,
+            origin=self.origin,
+            only_if_parent=True,
+        )
+        span.__enter__()
 
         fields = metadata.get("fields", [])
         for field in fields:
             if self._include_tracing_fields():
-                sentry_span.set_data(field, attrs.get(field))
-            else:
-                sentry_span.set_data(field, SENSITIVE_DATA_SUBSTITUTE)
-
-        scope.span = sentry_span
-        return (parent_sentry_span, sentry_span)
-
-    def on_close(self, span_id: str, span_state: TraceState) -> None:
-        if span_state is None:
-            return
-
-        parent_sentry_span, sentry_span = span_state
-        sentry_span.finish()
-        sentry_sdk.get_current_scope().span = parent_sentry_span
-
-    def on_record(self, span_id: str, values: str, span_state: TraceState) -> None:
-        if span_state is None:
-            return
-        _parent_sentry_span, sentry_span = span_state
-
-        deserialized_values = json.loads(values)
-        for key, value in deserialized_values.items():
-            if self._include_tracing_fields():
-                sentry_span.set_data(key, value)
+                span.set_data(field, attrs.get(field))
             else:
-                sentry_span.set_data(key, SENSITIVE_DATA_SUBSTITUTE)
+                span.set_data(field, SENSITIVE_DATA_SUBSTITUTE)
+
+        return span
+
+    def on_close(self, span_id: str, span: Optional[SentrySpan]) -> None:
+        if span is not None:
+            span.__exit__(None, None, None)
+
+    def on_record(self, span_id: str, values: str, span: Optional[SentrySpan]) -> None:
+        if span is not None:
+            deserialized_values = json.loads(values)
+            for key, value in deserialized_values.items():
+                if self._include_tracing_fields():
+                    span.set_data(key, value)
+                else:
+                    span.set_data(key, SENSITIVE_DATA_SUBSTITUTE)
 
 
 class RustTracingIntegration(Integration):

sentry_sdk/integrations/stdlib.py

@@ -96,6 +96,7 @@ def putrequest(self, method, url, *args, **kwargs):
             origin="auto.http.stdlib.httplib",
             only_if_parent=True,
         )
+        span.__enter__()
 
         data = {
             SPANDATA.HTTP_METHOD: method,
@@ -152,7 +153,7 @@ def getresponse(self, *args, **kwargs):
             span.set_http_status(int(rv.status))
             span.set_data("reason", rv.reason)
         finally:
-            span.finish()
+            span.__exit__(None, None, None)
 
         return rv
 

sentry_sdk/tracing.py

@@ -1,3 +1,4 @@
+import json
 import uuid
 import random
 import time
@@ -1632,8 +1633,12 @@ def finish(self, end_timestamp=None):
 
     def to_json(self):
         # type: () -> dict[str, Any]
-        # TODO-neel-potel for sampling context
-        pass
+        """
+        Only meant for testing. Not used internally anymore.
+        """
+        if not isinstance(self._otel_span, ReadableSpan):
+            return {}
+        return json.loads(self._otel_span.to_json())
 
     def get_trace_context(self):
         # type: () -> dict[str, Any]

tests/integrations/gcp/test_gcp.py

@@ -304,16 +304,12 @@ def cloud_function(functionhandler, event):
                 try:
                     traces_sampler.assert_any_call(
                         DictionaryContaining({
-                            "gcp_env": DictionaryContaining({
-                                "function_name": "chase_into_tree",
-                                "function_region": "dogpark",
-                                "function_project": "SquirrelChasing",
-                            }),
-                            "gcp_event": {
-                                "type": "chase",
-                                "chasers": ["Maisey", "Charlie"],
-                                "num_squirrels": 2,
-                            },
+                            "faas.name": "chase_into_tree",
+                            "faas.region": "dogpark",
+                            "gcp.function.identity": "func_ID",
+                            "gcp.function.entry_point": "cloud_function",
+                            "gcp.function.project": "SquirrelChasing",
+                            "cloud.provider": "gcp",
                         })
                     )
                 except AssertionError: